// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;
/// See [`BatchPutMessageInput`](crate::input::BatchPutMessageInput).
pub mod batch_put_message_input {
/// A builder for [`BatchPutMessageInput`](crate::input::BatchPutMessageInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
pub(crate) messages: std::option::Option<std::vec::Vec<crate::model::Message>>,
}
impl Builder {
/// <p>The name of the channel where the messages are sent.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel where the messages are sent.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// Appends an item to `messages`.
///
/// To override the contents of this collection use [`set_messages`](Self::set_messages).
///
/// <p>The list of messages to be sent. Each message has the format: { "messageId": "string", "payload": "string"}.</p>
/// <p>The field names of message payloads (data) that you send to IoT Analytics:</p>
/// <ul>
/// <li> <p>Must contain only alphanumeric characters and undescores (_). No other special characters are allowed.</p> </li>
/// <li> <p>Must begin with an alphabetic character or single underscore (_).</p> </li>
/// <li> <p>Cannot contain hyphens (-).</p> </li>
/// <li> <p>In regular expression terms: "^[A-Za-z_]([A-Za-z0-9]*|[A-Za-z0-9][A-Za-z0-9_]*)$". </p> </li>
/// <li> <p>Cannot be more than 255 characters.</p> </li>
/// <li> <p>Are case insensitive. (Fields named foo and FOO in the same payload are considered duplicates.)</p> </li>
/// </ul>
/// <p>For example, {"temp_01": 29} or {"_temp_01": 29} are valid, but {"temp-01": 29}, {"01_temp": 29} or {"__temp_01": 29} are invalid in message payloads. </p>
pub fn messages(mut self, input: crate::model::Message) -> Self {
let mut v = self.messages.unwrap_or_default();
v.push(input);
self.messages = Some(v);
self
}
/// <p>The list of messages to be sent. Each message has the format: { "messageId": "string", "payload": "string"}.</p>
/// <p>The field names of message payloads (data) that you send to IoT Analytics:</p>
/// <ul>
/// <li> <p>Must contain only alphanumeric characters and undescores (_). No other special characters are allowed.</p> </li>
/// <li> <p>Must begin with an alphabetic character or single underscore (_).</p> </li>
/// <li> <p>Cannot contain hyphens (-).</p> </li>
/// <li> <p>In regular expression terms: "^[A-Za-z_]([A-Za-z0-9]*|[A-Za-z0-9][A-Za-z0-9_]*)$". </p> </li>
/// <li> <p>Cannot be more than 255 characters.</p> </li>
/// <li> <p>Are case insensitive. (Fields named foo and FOO in the same payload are considered duplicates.)</p> </li>
/// </ul>
/// <p>For example, {"temp_01": 29} or {"_temp_01": 29} are valid, but {"temp-01": 29}, {"01_temp": 29} or {"__temp_01": 29} are invalid in message payloads. </p>
pub fn set_messages(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Message>>,
) -> Self {
self.messages = input;
self
}
/// Consumes the builder and constructs a [`BatchPutMessageInput`](crate::input::BatchPutMessageInput).
pub fn build(
self,
) -> Result<crate::input::BatchPutMessageInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::BatchPutMessageInput {
channel_name: self.channel_name,
messages: self.messages,
})
}
}
}
impl BatchPutMessageInput {
/// Consumes the builder and constructs an Operation<[`BatchPutMessage`](crate::operation::BatchPutMessage)>
#[allow(unused_mut)]
#[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::BatchPutMessage,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::BatchPutMessageInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/messages/batch").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::BatchPutMessageInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_batch_put_message(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::BatchPutMessage::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"BatchPutMessage",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`BatchPutMessageInput`](crate::input::BatchPutMessageInput).
pub fn builder() -> crate::input::batch_put_message_input::Builder {
crate::input::batch_put_message_input::Builder::default()
}
}
/// See [`CancelPipelineReprocessingInput`](crate::input::CancelPipelineReprocessingInput).
pub mod cancel_pipeline_reprocessing_input {
/// A builder for [`CancelPipelineReprocessingInput`](crate::input::CancelPipelineReprocessingInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
pub(crate) reprocessing_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of pipeline for which data reprocessing is canceled.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of pipeline for which data reprocessing is canceled.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// <p>The ID of the reprocessing task (returned by <code>StartPipelineReprocessing</code>).</p>
pub fn reprocessing_id(mut self, input: impl Into<std::string::String>) -> Self {
self.reprocessing_id = Some(input.into());
self
}
/// <p>The ID of the reprocessing task (returned by <code>StartPipelineReprocessing</code>).</p>
pub fn set_reprocessing_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.reprocessing_id = input;
self
}
/// Consumes the builder and constructs a [`CancelPipelineReprocessingInput`](crate::input::CancelPipelineReprocessingInput).
pub fn build(
self,
) -> Result<
crate::input::CancelPipelineReprocessingInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CancelPipelineReprocessingInput {
pipeline_name: self.pipeline_name,
reprocessing_id: self.reprocessing_id,
})
}
}
}
impl CancelPipelineReprocessingInput {
/// Consumes the builder and constructs an Operation<[`CancelPipelineReprocessing`](crate::operation::CancelPipelineReprocessing)>
#[allow(unused_mut)]
#[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::CancelPipelineReprocessing,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CancelPipelineReprocessingInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_1 = &_input.pipeline_name;
let input_1 = input_1.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
)
})?;
let pipeline_name = aws_smithy_http::label::fmt_string(
input_1,
aws_smithy_http::label::EncodingStrategy::Default,
);
if pipeline_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
),
);
}
let input_2 = &_input.reprocessing_id;
let input_2 = input_2.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"reprocessing_id",
"cannot be empty or unset",
)
})?;
let reprocessing_id = aws_smithy_http::label::fmt_string(
input_2,
aws_smithy_http::label::EncodingStrategy::Default,
);
if reprocessing_id.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"reprocessing_id",
"cannot be empty or unset",
),
);
}
write!(
output,
"/pipelines/{pipelineName}/reprocessing/{reprocessingId}",
pipelineName = pipeline_name,
reprocessingId = reprocessing_id
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CancelPipelineReprocessingInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CancelPipelineReprocessing::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CancelPipelineReprocessing",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CancelPipelineReprocessingInput`](crate::input::CancelPipelineReprocessingInput).
pub fn builder() -> crate::input::cancel_pipeline_reprocessing_input::Builder {
crate::input::cancel_pipeline_reprocessing_input::Builder::default()
}
}
/// See [`CreateChannelInput`](crate::input::CreateChannelInput).
pub mod create_channel_input {
/// A builder for [`CreateChannelInput`](crate::input::CreateChannelInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
pub(crate) channel_storage: std::option::Option<crate::model::ChannelStorage>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The name of the channel.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn channel_storage(mut self, input: crate::model::ChannelStorage) -> Self {
self.channel_storage = Some(input);
self
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn set_channel_storage(
mut self,
input: std::option::Option<crate::model::ChannelStorage>,
) -> Self {
self.channel_storage = input;
self
}
/// <p>How long, in days, message data is kept for the channel. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>How long, in days, message data is kept for the channel. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Metadata which can be used to manage the channel.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Metadata which can be used to manage the channel.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateChannelInput`](crate::input::CreateChannelInput).
pub fn build(
self,
) -> Result<crate::input::CreateChannelInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateChannelInput {
channel_name: self.channel_name,
channel_storage: self.channel_storage,
retention_period: self.retention_period,
tags: self.tags,
})
}
}
}
impl CreateChannelInput {
/// Consumes the builder and constructs an Operation<[`CreateChannel`](crate::operation::CreateChannel)>
#[allow(unused_mut)]
#[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::CreateChannel,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateChannelInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/channels").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateChannelInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_channel(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateChannel::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateChannel",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateChannelInput`](crate::input::CreateChannelInput).
pub fn builder() -> crate::input::create_channel_input::Builder {
crate::input::create_channel_input::Builder::default()
}
}
/// See [`CreateDatasetInput`](crate::input::CreateDatasetInput).
pub mod create_dataset_input {
/// A builder for [`CreateDatasetInput`](crate::input::CreateDatasetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) actions: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
pub(crate) triggers: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
pub(crate) content_delivery_rules:
std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
pub(crate) versioning_configuration:
std::option::Option<crate::model::VersioningConfiguration>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub(crate) late_data_rules: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
}
impl Builder {
/// <p>The name of the dataset.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// Appends an item to `actions`.
///
/// To override the contents of this collection use [`set_actions`](Self::set_actions).
///
/// <p>A list of actions that create the dataset contents.</p>
pub fn actions(mut self, input: crate::model::DatasetAction) -> Self {
let mut v = self.actions.unwrap_or_default();
v.push(input);
self.actions = Some(v);
self
}
/// <p>A list of actions that create the dataset contents.</p>
pub fn set_actions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
) -> Self {
self.actions = input;
self
}
/// Appends an item to `triggers`.
///
/// To override the contents of this collection use [`set_triggers`](Self::set_triggers).
///
/// <p>A list of triggers. A trigger causes dataset contents to be populated at a specified time interval or when another dataset's contents are created. The list of triggers can be empty or contain up to five <code>DataSetTrigger</code> objects.</p>
pub fn triggers(mut self, input: crate::model::DatasetTrigger) -> Self {
let mut v = self.triggers.unwrap_or_default();
v.push(input);
self.triggers = Some(v);
self
}
/// <p>A list of triggers. A trigger causes dataset contents to be populated at a specified time interval or when another dataset's contents are created. The list of triggers can be empty or contain up to five <code>DataSetTrigger</code> objects.</p>
pub fn set_triggers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
) -> Self {
self.triggers = input;
self
}
/// Appends an item to `content_delivery_rules`.
///
/// To override the contents of this collection use [`set_content_delivery_rules`](Self::set_content_delivery_rules).
///
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn content_delivery_rules(
mut self,
input: crate::model::DatasetContentDeliveryRule,
) -> Self {
let mut v = self.content_delivery_rules.unwrap_or_default();
v.push(input);
self.content_delivery_rules = Some(v);
self
}
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn set_content_delivery_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
) -> Self {
self.content_delivery_rules = input;
self
}
/// <p>Optional. How long, in days, versions of dataset contents are kept for the dataset. If not specified or set to <code>null</code>, versions of dataset contents are retained for at most 90 days. The number of versions of dataset contents retained is determined by the <code>versioningConfiguration</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions"> Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>Optional. How long, in days, versions of dataset contents are kept for the dataset. If not specified or set to <code>null</code>, versions of dataset contents are retained for at most 90 days. The number of versions of dataset contents retained is determined by the <code>versioningConfiguration</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions"> Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn versioning_configuration(
mut self,
input: crate::model::VersioningConfiguration,
) -> Self {
self.versioning_configuration = Some(input);
self
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn set_versioning_configuration(
mut self,
input: std::option::Option<crate::model::VersioningConfiguration>,
) -> Self {
self.versioning_configuration = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Metadata which can be used to manage the dataset.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Metadata which can be used to manage the dataset.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Appends an item to `late_data_rules`.
///
/// To override the contents of this collection use [`set_late_data_rules`](Self::set_late_data_rules).
///
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn late_data_rules(mut self, input: crate::model::LateDataRule) -> Self {
let mut v = self.late_data_rules.unwrap_or_default();
v.push(input);
self.late_data_rules = Some(v);
self
}
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn set_late_data_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
) -> Self {
self.late_data_rules = input;
self
}
/// Consumes the builder and constructs a [`CreateDatasetInput`](crate::input::CreateDatasetInput).
pub fn build(
self,
) -> Result<crate::input::CreateDatasetInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateDatasetInput {
dataset_name: self.dataset_name,
actions: self.actions,
triggers: self.triggers,
content_delivery_rules: self.content_delivery_rules,
retention_period: self.retention_period,
versioning_configuration: self.versioning_configuration,
tags: self.tags,
late_data_rules: self.late_data_rules,
})
}
}
}
impl CreateDatasetInput {
/// Consumes the builder and constructs an Operation<[`CreateDataset`](crate::operation::CreateDataset)>
#[allow(unused_mut)]
#[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::CreateDataset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDatasetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/datasets").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDatasetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_dataset(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDataset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDataset",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDatasetInput`](crate::input::CreateDatasetInput).
pub fn builder() -> crate::input::create_dataset_input::Builder {
crate::input::create_dataset_input::Builder::default()
}
}
/// See [`CreateDatasetContentInput`](crate::input::CreateDatasetContentInput).
pub mod create_dataset_content_input {
/// A builder for [`CreateDatasetContentInput`](crate::input::CreateDatasetContentInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the dataset.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// <p>The version ID of the dataset content. To specify <code>versionId</code> for a dataset content, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The version ID of the dataset content. To specify <code>versionId</code> for a dataset content, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`CreateDatasetContentInput`](crate::input::CreateDatasetContentInput).
pub fn build(
self,
) -> Result<
crate::input::CreateDatasetContentInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::CreateDatasetContentInput {
dataset_name: self.dataset_name,
version_id: self.version_id,
})
}
}
}
impl CreateDatasetContentInput {
/// Consumes the builder and constructs an Operation<[`CreateDatasetContent`](crate::operation::CreateDatasetContent)>
#[allow(unused_mut)]
#[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::CreateDatasetContent,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDatasetContentInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_3 = &_input.dataset_name;
let input_3 = input_3.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_3,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}/content",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDatasetContentInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_dataset_content(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDatasetContent::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDatasetContent",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDatasetContentInput`](crate::input::CreateDatasetContentInput).
pub fn builder() -> crate::input::create_dataset_content_input::Builder {
crate::input::create_dataset_content_input::Builder::default()
}
}
/// See [`CreateDatastoreInput`](crate::input::CreateDatastoreInput).
pub mod create_datastore_input {
/// A builder for [`CreateDatastoreInput`](crate::input::CreateDatastoreInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) datastore_name: std::option::Option<std::string::String>,
pub(crate) datastore_storage: std::option::Option<crate::model::DatastoreStorage>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub(crate) file_format_configuration:
std::option::Option<crate::model::FileFormatConfiguration>,
pub(crate) datastore_partitions: std::option::Option<crate::model::DatastorePartitions>,
}
impl Builder {
/// <p>The name of the data store.</p>
pub fn datastore_name(mut self, input: impl Into<std::string::String>) -> Self {
self.datastore_name = Some(input.into());
self
}
/// <p>The name of the data store.</p>
pub fn set_datastore_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.datastore_name = input;
self
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn datastore_storage(mut self, input: crate::model::DatastoreStorage) -> Self {
self.datastore_storage = Some(input);
self
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn set_datastore_storage(
mut self,
input: std::option::Option<crate::model::DatastoreStorage>,
) -> Self {
self.datastore_storage = input;
self
}
/// <p>How long, in days, message data is kept for the data store. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>How long, in days, message data is kept for the data store. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Metadata which can be used to manage the data store.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Metadata which can be used to manage the data store.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn file_format_configuration(
mut self,
input: crate::model::FileFormatConfiguration,
) -> Self {
self.file_format_configuration = Some(input);
self
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn set_file_format_configuration(
mut self,
input: std::option::Option<crate::model::FileFormatConfiguration>,
) -> Self {
self.file_format_configuration = input;
self
}
/// <p> Contains information about the partition dimensions in a data store. </p>
pub fn datastore_partitions(mut self, input: crate::model::DatastorePartitions) -> Self {
self.datastore_partitions = Some(input);
self
}
/// <p> Contains information about the partition dimensions in a data store. </p>
pub fn set_datastore_partitions(
mut self,
input: std::option::Option<crate::model::DatastorePartitions>,
) -> Self {
self.datastore_partitions = input;
self
}
/// Consumes the builder and constructs a [`CreateDatastoreInput`](crate::input::CreateDatastoreInput).
pub fn build(
self,
) -> Result<crate::input::CreateDatastoreInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateDatastoreInput {
datastore_name: self.datastore_name,
datastore_storage: self.datastore_storage,
retention_period: self.retention_period,
tags: self.tags,
file_format_configuration: self.file_format_configuration,
datastore_partitions: self.datastore_partitions,
})
}
}
}
impl CreateDatastoreInput {
/// Consumes the builder and constructs an Operation<[`CreateDatastore`](crate::operation::CreateDatastore)>
#[allow(unused_mut)]
#[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::CreateDatastore,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreateDatastoreInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/datastores").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateDatastoreInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_datastore(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateDatastore::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateDatastore",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateDatastoreInput`](crate::input::CreateDatastoreInput).
pub fn builder() -> crate::input::create_datastore_input::Builder {
crate::input::create_datastore_input::Builder::default()
}
}
/// See [`CreatePipelineInput`](crate::input::CreatePipelineInput).
pub mod create_pipeline_input {
/// A builder for [`CreatePipelineInput`](crate::input::CreatePipelineInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
pub(crate) pipeline_activities:
std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The name of the pipeline.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of the pipeline.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// Appends an item to `pipeline_activities`.
///
/// To override the contents of this collection use [`set_pipeline_activities`](Self::set_pipeline_activities).
///
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda unctions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn pipeline_activities(mut self, input: crate::model::PipelineActivity) -> Self {
let mut v = self.pipeline_activities.unwrap_or_default();
v.push(input);
self.pipeline_activities = Some(v);
self
}
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda unctions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn set_pipeline_activities(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
) -> Self {
self.pipeline_activities = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Metadata which can be used to manage the pipeline.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Metadata which can be used to manage the pipeline.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreatePipelineInput`](crate::input::CreatePipelineInput).
pub fn build(
self,
) -> Result<crate::input::CreatePipelineInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreatePipelineInput {
pipeline_name: self.pipeline_name,
pipeline_activities: self.pipeline_activities,
tags: self.tags,
})
}
}
}
impl CreatePipelineInput {
/// Consumes the builder and constructs an Operation<[`CreatePipeline`](crate::operation::CreatePipeline)>
#[allow(unused_mut)]
#[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::CreatePipeline,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::CreatePipelineInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/pipelines").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreatePipelineInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_create_pipeline(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreatePipeline::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreatePipeline",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreatePipelineInput`](crate::input::CreatePipelineInput).
pub fn builder() -> crate::input::create_pipeline_input::Builder {
crate::input::create_pipeline_input::Builder::default()
}
}
/// See [`DeleteChannelInput`](crate::input::DeleteChannelInput).
pub mod delete_channel_input {
/// A builder for [`DeleteChannelInput`](crate::input::DeleteChannelInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the channel to delete.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel to delete.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteChannelInput`](crate::input::DeleteChannelInput).
pub fn build(
self,
) -> Result<crate::input::DeleteChannelInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteChannelInput {
channel_name: self.channel_name,
})
}
}
}
impl DeleteChannelInput {
/// Consumes the builder and constructs an Operation<[`DeleteChannel`](crate::operation::DeleteChannel)>
#[allow(unused_mut)]
#[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::DeleteChannel,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteChannelInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_4 = &_input.channel_name;
let input_4 = input_4.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
)
})?;
let channel_name = aws_smithy_http::label::fmt_string(
input_4,
aws_smithy_http::label::EncodingStrategy::Default,
);
if channel_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/channels/{channelName}",
channelName = channel_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteChannelInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteChannel::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteChannel",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteChannelInput`](crate::input::DeleteChannelInput).
pub fn builder() -> crate::input::delete_channel_input::Builder {
crate::input::delete_channel_input::Builder::default()
}
}
/// See [`DeleteDatasetInput`](crate::input::DeleteDatasetInput).
pub mod delete_dataset_input {
/// A builder for [`DeleteDatasetInput`](crate::input::DeleteDatasetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the dataset to delete.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset to delete.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteDatasetInput`](crate::input::DeleteDatasetInput).
pub fn build(
self,
) -> Result<crate::input::DeleteDatasetInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteDatasetInput {
dataset_name: self.dataset_name,
})
}
}
}
impl DeleteDatasetInput {
/// Consumes the builder and constructs an Operation<[`DeleteDataset`](crate::operation::DeleteDataset)>
#[allow(unused_mut)]
#[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::DeleteDataset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDatasetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_5 = &_input.dataset_name;
let input_5 = input_5.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_5,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDatasetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDataset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDataset",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDatasetInput`](crate::input::DeleteDatasetInput).
pub fn builder() -> crate::input::delete_dataset_input::Builder {
crate::input::delete_dataset_input::Builder::default()
}
}
/// See [`DeleteDatasetContentInput`](crate::input::DeleteDatasetContentInput).
pub mod delete_dataset_content_input {
/// A builder for [`DeleteDatasetContentInput`](crate::input::DeleteDatasetContentInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the dataset whose content is deleted.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset whose content is deleted.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// <p>The version of the dataset whose content is deleted. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The version of the dataset whose content is deleted. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteDatasetContentInput`](crate::input::DeleteDatasetContentInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteDatasetContentInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteDatasetContentInput {
dataset_name: self.dataset_name,
version_id: self.version_id,
})
}
}
}
impl DeleteDatasetContentInput {
/// Consumes the builder and constructs an Operation<[`DeleteDatasetContent`](crate::operation::DeleteDatasetContent)>
#[allow(unused_mut)]
#[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::DeleteDatasetContent,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDatasetContentInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_6 = &_input.dataset_name;
let input_6 = input_6.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_6,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}/content",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::DeleteDatasetContentInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_7) = &_input.version_id {
{
query.push_kv("versionId", &aws_smithy_http::query::fmt_string(&inner_7));
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDatasetContentInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDatasetContent::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDatasetContent",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDatasetContentInput`](crate::input::DeleteDatasetContentInput).
pub fn builder() -> crate::input::delete_dataset_content_input::Builder {
crate::input::delete_dataset_content_input::Builder::default()
}
}
/// See [`DeleteDatastoreInput`](crate::input::DeleteDatastoreInput).
pub mod delete_datastore_input {
/// A builder for [`DeleteDatastoreInput`](crate::input::DeleteDatastoreInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) datastore_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the data store to delete.</p>
pub fn datastore_name(mut self, input: impl Into<std::string::String>) -> Self {
self.datastore_name = Some(input.into());
self
}
/// <p>The name of the data store to delete.</p>
pub fn set_datastore_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.datastore_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteDatastoreInput`](crate::input::DeleteDatastoreInput).
pub fn build(
self,
) -> Result<crate::input::DeleteDatastoreInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteDatastoreInput {
datastore_name: self.datastore_name,
})
}
}
}
impl DeleteDatastoreInput {
/// Consumes the builder and constructs an Operation<[`DeleteDatastore`](crate::operation::DeleteDatastore)>
#[allow(unused_mut)]
#[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::DeleteDatastore,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeleteDatastoreInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_8 = &_input.datastore_name;
let input_8 = input_8.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
)
})?;
let datastore_name = aws_smithy_http::label::fmt_string(
input_8,
aws_smithy_http::label::EncodingStrategy::Default,
);
if datastore_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datastores/{datastoreName}",
datastoreName = datastore_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteDatastoreInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteDatastore::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteDatastore",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteDatastoreInput`](crate::input::DeleteDatastoreInput).
pub fn builder() -> crate::input::delete_datastore_input::Builder {
crate::input::delete_datastore_input::Builder::default()
}
}
/// See [`DeletePipelineInput`](crate::input::DeletePipelineInput).
pub mod delete_pipeline_input {
/// A builder for [`DeletePipelineInput`](crate::input::DeletePipelineInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the pipeline to delete.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of the pipeline to delete.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// Consumes the builder and constructs a [`DeletePipelineInput`](crate::input::DeletePipelineInput).
pub fn build(
self,
) -> Result<crate::input::DeletePipelineInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeletePipelineInput {
pipeline_name: self.pipeline_name,
})
}
}
}
impl DeletePipelineInput {
/// Consumes the builder and constructs an Operation<[`DeletePipeline`](crate::operation::DeletePipeline)>
#[allow(unused_mut)]
#[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::DeletePipeline,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DeletePipelineInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_9 = &_input.pipeline_name;
let input_9 = input_9.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
)
})?;
let pipeline_name = aws_smithy_http::label::fmt_string(
input_9,
aws_smithy_http::label::EncodingStrategy::Default,
);
if pipeline_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/pipelines/{pipelineName}",
pipelineName = pipeline_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeletePipelineInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeletePipeline::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeletePipeline",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeletePipelineInput`](crate::input::DeletePipelineInput).
pub fn builder() -> crate::input::delete_pipeline_input::Builder {
crate::input::delete_pipeline_input::Builder::default()
}
}
/// See [`DescribeChannelInput`](crate::input::DescribeChannelInput).
pub mod describe_channel_input {
/// A builder for [`DescribeChannelInput`](crate::input::DescribeChannelInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
pub(crate) include_statistics: std::option::Option<bool>,
}
impl Builder {
/// <p>The name of the channel whose information is retrieved.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel whose information is retrieved.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// <p>If true, additional statistical information about the channel is included in the response. This feature can't be used with a channel whose S3 storage is customer-managed.</p>
pub fn include_statistics(mut self, input: bool) -> Self {
self.include_statistics = Some(input);
self
}
/// <p>If true, additional statistical information about the channel is included in the response. This feature can't be used with a channel whose S3 storage is customer-managed.</p>
pub fn set_include_statistics(mut self, input: std::option::Option<bool>) -> Self {
self.include_statistics = input;
self
}
/// Consumes the builder and constructs a [`DescribeChannelInput`](crate::input::DescribeChannelInput).
pub fn build(
self,
) -> Result<crate::input::DescribeChannelInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeChannelInput {
channel_name: self.channel_name,
include_statistics: self.include_statistics.unwrap_or_default(),
})
}
}
}
impl DescribeChannelInput {
/// Consumes the builder and constructs an Operation<[`DescribeChannel`](crate::operation::DescribeChannel)>
#[allow(unused_mut)]
#[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::DescribeChannel,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DescribeChannelInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_10 = &_input.channel_name;
let input_10 = input_10.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
)
})?;
let channel_name = aws_smithy_http::label::fmt_string(
input_10,
aws_smithy_http::label::EncodingStrategy::Default,
);
if channel_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/channels/{channelName}",
channelName = channel_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::DescribeChannelInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if _input.include_statistics {
query.push_kv(
"includeStatistics",
aws_smithy_types::primitive::Encoder::from(_input.include_statistics)
.encode(),
);
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeChannelInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeChannel::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeChannel",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeChannelInput`](crate::input::DescribeChannelInput).
pub fn builder() -> crate::input::describe_channel_input::Builder {
crate::input::describe_channel_input::Builder::default()
}
}
/// See [`DescribeDatasetInput`](crate::input::DescribeDatasetInput).
pub mod describe_dataset_input {
/// A builder for [`DescribeDatasetInput`](crate::input::DescribeDatasetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the dataset whose information is retrieved.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset whose information is retrieved.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// Consumes the builder and constructs a [`DescribeDatasetInput`](crate::input::DescribeDatasetInput).
pub fn build(
self,
) -> Result<crate::input::DescribeDatasetInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeDatasetInput {
dataset_name: self.dataset_name,
})
}
}
}
impl DescribeDatasetInput {
/// Consumes the builder and constructs an Operation<[`DescribeDataset`](crate::operation::DescribeDataset)>
#[allow(unused_mut)]
#[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::DescribeDataset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DescribeDatasetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_11 = &_input.dataset_name;
let input_11 = input_11.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_11,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeDatasetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeDataset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeDataset",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeDatasetInput`](crate::input::DescribeDatasetInput).
pub fn builder() -> crate::input::describe_dataset_input::Builder {
crate::input::describe_dataset_input::Builder::default()
}
}
/// See [`DescribeDatastoreInput`](crate::input::DescribeDatastoreInput).
pub mod describe_datastore_input {
/// A builder for [`DescribeDatastoreInput`](crate::input::DescribeDatastoreInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) datastore_name: std::option::Option<std::string::String>,
pub(crate) include_statistics: std::option::Option<bool>,
}
impl Builder {
/// <p>The name of the data store</p>
pub fn datastore_name(mut self, input: impl Into<std::string::String>) -> Self {
self.datastore_name = Some(input.into());
self
}
/// <p>The name of the data store</p>
pub fn set_datastore_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.datastore_name = input;
self
}
/// <p>If true, additional statistical information about the data store is included in the response. This feature can't be used with a data store whose S3 storage is customer-managed.</p>
pub fn include_statistics(mut self, input: bool) -> Self {
self.include_statistics = Some(input);
self
}
/// <p>If true, additional statistical information about the data store is included in the response. This feature can't be used with a data store whose S3 storage is customer-managed.</p>
pub fn set_include_statistics(mut self, input: std::option::Option<bool>) -> Self {
self.include_statistics = input;
self
}
/// Consumes the builder and constructs a [`DescribeDatastoreInput`](crate::input::DescribeDatastoreInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeDatastoreInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeDatastoreInput {
datastore_name: self.datastore_name,
include_statistics: self.include_statistics.unwrap_or_default(),
})
}
}
}
impl DescribeDatastoreInput {
/// Consumes the builder and constructs an Operation<[`DescribeDatastore`](crate::operation::DescribeDatastore)>
#[allow(unused_mut)]
#[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::DescribeDatastore,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DescribeDatastoreInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_12 = &_input.datastore_name;
let input_12 = input_12.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
)
})?;
let datastore_name = aws_smithy_http::label::fmt_string(
input_12,
aws_smithy_http::label::EncodingStrategy::Default,
);
if datastore_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datastores/{datastoreName}",
datastoreName = datastore_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::DescribeDatastoreInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if _input.include_statistics {
query.push_kv(
"includeStatistics",
aws_smithy_types::primitive::Encoder::from(_input.include_statistics)
.encode(),
);
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeDatastoreInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeDatastore::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeDatastore",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeDatastoreInput`](crate::input::DescribeDatastoreInput).
pub fn builder() -> crate::input::describe_datastore_input::Builder {
crate::input::describe_datastore_input::Builder::default()
}
}
/// See [`DescribeLoggingOptionsInput`](crate::input::DescribeLoggingOptionsInput).
pub mod describe_logging_options_input {
/// A builder for [`DescribeLoggingOptionsInput`](crate::input::DescribeLoggingOptionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
/// Consumes the builder and constructs a [`DescribeLoggingOptionsInput`](crate::input::DescribeLoggingOptionsInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeLoggingOptionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeLoggingOptionsInput {})
}
}
}
impl DescribeLoggingOptionsInput {
/// Consumes the builder and constructs an Operation<[`DescribeLoggingOptions`](crate::operation::DescribeLoggingOptions)>
#[allow(unused_mut)]
#[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::DescribeLoggingOptions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DescribeLoggingOptionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/logging").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeLoggingOptionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeLoggingOptions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeLoggingOptions",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeLoggingOptionsInput`](crate::input::DescribeLoggingOptionsInput).
pub fn builder() -> crate::input::describe_logging_options_input::Builder {
crate::input::describe_logging_options_input::Builder::default()
}
}
/// See [`DescribePipelineInput`](crate::input::DescribePipelineInput).
pub mod describe_pipeline_input {
/// A builder for [`DescribePipelineInput`](crate::input::DescribePipelineInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the pipeline whose information is retrieved.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of the pipeline whose information is retrieved.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// Consumes the builder and constructs a [`DescribePipelineInput`](crate::input::DescribePipelineInput).
pub fn build(
self,
) -> Result<
crate::input::DescribePipelineInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribePipelineInput {
pipeline_name: self.pipeline_name,
})
}
}
}
impl DescribePipelineInput {
/// Consumes the builder and constructs an Operation<[`DescribePipeline`](crate::operation::DescribePipeline)>
#[allow(unused_mut)]
#[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::DescribePipeline,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::DescribePipelineInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_13 = &_input.pipeline_name;
let input_13 = input_13.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
)
})?;
let pipeline_name = aws_smithy_http::label::fmt_string(
input_13,
aws_smithy_http::label::EncodingStrategy::Default,
);
if pipeline_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/pipelines/{pipelineName}",
pipelineName = pipeline_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribePipelineInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribePipeline::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribePipeline",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribePipelineInput`](crate::input::DescribePipelineInput).
pub fn builder() -> crate::input::describe_pipeline_input::Builder {
crate::input::describe_pipeline_input::Builder::default()
}
}
/// See [`GetDatasetContentInput`](crate::input::GetDatasetContentInput).
pub mod get_dataset_content_input {
/// A builder for [`GetDatasetContentInput`](crate::input::GetDatasetContentInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) version_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the dataset whose contents are retrieved.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset whose contents are retrieved.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// <p>The version of the dataset whose contents are retrieved. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest or latest successfully completed dataset. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn version_id(mut self, input: impl Into<std::string::String>) -> Self {
self.version_id = Some(input.into());
self
}
/// <p>The version of the dataset whose contents are retrieved. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest or latest successfully completed dataset. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn set_version_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.version_id = input;
self
}
/// Consumes the builder and constructs a [`GetDatasetContentInput`](crate::input::GetDatasetContentInput).
pub fn build(
self,
) -> Result<
crate::input::GetDatasetContentInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetDatasetContentInput {
dataset_name: self.dataset_name,
version_id: self.version_id,
})
}
}
}
impl GetDatasetContentInput {
/// Consumes the builder and constructs an Operation<[`GetDatasetContent`](crate::operation::GetDatasetContent)>
#[allow(unused_mut)]
#[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::GetDatasetContent,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::GetDatasetContentInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_14 = &_input.dataset_name;
let input_14 = input_14.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_14,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}/content",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::GetDatasetContentInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_15) = &_input.version_id {
{
query.push_kv("versionId", &aws_smithy_http::query::fmt_string(&inner_15));
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetDatasetContentInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::GetDatasetContent::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetDatasetContent",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetDatasetContentInput`](crate::input::GetDatasetContentInput).
pub fn builder() -> crate::input::get_dataset_content_input::Builder {
crate::input::get_dataset_content_input::Builder::default()
}
}
/// See [`ListChannelsInput`](crate::input::ListChannelsInput).
pub mod list_channels_input {
/// A builder for [`ListChannelsInput`](crate::input::ListChannelsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
/// <p>The token for the next set of results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListChannelsInput`](crate::input::ListChannelsInput).
pub fn build(
self,
) -> Result<crate::input::ListChannelsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListChannelsInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListChannelsInput {
/// Consumes the builder and constructs an Operation<[`ListChannels`](crate::operation::ListChannels)>
#[allow(unused_mut)]
#[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::ListChannels,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListChannelsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/channels").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListChannelsInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_16) = &_input.next_token {
{
query.push_kv("nextToken", &aws_smithy_http::query::fmt_string(&inner_16));
}
}
if let Some(inner_17) = &_input.max_results {
if *inner_17 != 0 {
query.push_kv(
"maxResults",
aws_smithy_types::primitive::Encoder::from(*inner_17).encode(),
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListChannelsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListChannels::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListChannels",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListChannelsInput`](crate::input::ListChannelsInput).
pub fn builder() -> crate::input::list_channels_input::Builder {
crate::input::list_channels_input::Builder::default()
}
}
/// See [`ListDatasetContentsInput`](crate::input::ListDatasetContentsInput).
pub mod list_dataset_contents_input {
/// A builder for [`ListDatasetContentsInput`](crate::input::ListDatasetContentsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) scheduled_on_or_after: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) scheduled_before: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The name of the dataset whose contents information you want to list.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset whose contents information you want to list.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// <p>The token for the next set of results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return in this request.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return in this request.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled on or after the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn scheduled_on_or_after(mut self, input: aws_smithy_types::DateTime) -> Self {
self.scheduled_on_or_after = Some(input);
self
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled on or after the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn set_scheduled_on_or_after(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.scheduled_on_or_after = input;
self
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled before the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn scheduled_before(mut self, input: aws_smithy_types::DateTime) -> Self {
self.scheduled_before = Some(input);
self
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled before the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn set_scheduled_before(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.scheduled_before = input;
self
}
/// Consumes the builder and constructs a [`ListDatasetContentsInput`](crate::input::ListDatasetContentsInput).
pub fn build(
self,
) -> Result<
crate::input::ListDatasetContentsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListDatasetContentsInput {
dataset_name: self.dataset_name,
next_token: self.next_token,
max_results: self.max_results,
scheduled_on_or_after: self.scheduled_on_or_after,
scheduled_before: self.scheduled_before,
})
}
}
}
impl ListDatasetContentsInput {
/// Consumes the builder and constructs an Operation<[`ListDatasetContents`](crate::operation::ListDatasetContents)>
#[allow(unused_mut)]
#[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::ListDatasetContents,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDatasetContentsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_18 = &_input.dataset_name;
let input_18 = input_18.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_18,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}/contents",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListDatasetContentsInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_19) = &_input.next_token {
{
query.push_kv("nextToken", &aws_smithy_http::query::fmt_string(&inner_19));
}
}
if let Some(inner_20) = &_input.max_results {
if *inner_20 != 0 {
query.push_kv(
"maxResults",
aws_smithy_types::primitive::Encoder::from(*inner_20).encode(),
);
}
}
if let Some(inner_21) = &_input.scheduled_on_or_after {
{
query.push_kv(
"scheduledOnOrAfter",
&aws_smithy_http::query::fmt_timestamp(
inner_21,
aws_smithy_types::date_time::Format::DateTime,
)?,
);
}
}
if let Some(inner_22) = &_input.scheduled_before {
{
query.push_kv(
"scheduledBefore",
&aws_smithy_http::query::fmt_timestamp(
inner_22,
aws_smithy_types::date_time::Format::DateTime,
)?,
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDatasetContentsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDatasetContents::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDatasetContents",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDatasetContentsInput`](crate::input::ListDatasetContentsInput).
pub fn builder() -> crate::input::list_dataset_contents_input::Builder {
crate::input::list_dataset_contents_input::Builder::default()
}
}
/// See [`ListDatasetsInput`](crate::input::ListDatasetsInput).
pub mod list_datasets_input {
/// A builder for [`ListDatasetsInput`](crate::input::ListDatasetsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
/// <p>The token for the next set of results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListDatasetsInput`](crate::input::ListDatasetsInput).
pub fn build(
self,
) -> Result<crate::input::ListDatasetsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListDatasetsInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListDatasetsInput {
/// Consumes the builder and constructs an Operation<[`ListDatasets`](crate::operation::ListDatasets)>
#[allow(unused_mut)]
#[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::ListDatasets,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDatasetsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/datasets").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListDatasetsInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_23) = &_input.next_token {
{
query.push_kv("nextToken", &aws_smithy_http::query::fmt_string(&inner_23));
}
}
if let Some(inner_24) = &_input.max_results {
if *inner_24 != 0 {
query.push_kv(
"maxResults",
aws_smithy_types::primitive::Encoder::from(*inner_24).encode(),
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDatasetsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDatasets::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDatasets",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDatasetsInput`](crate::input::ListDatasetsInput).
pub fn builder() -> crate::input::list_datasets_input::Builder {
crate::input::list_datasets_input::Builder::default()
}
}
/// See [`ListDatastoresInput`](crate::input::ListDatastoresInput).
pub mod list_datastores_input {
/// A builder for [`ListDatastoresInput`](crate::input::ListDatastoresInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
/// <p>The token for the next set of results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListDatastoresInput`](crate::input::ListDatastoresInput).
pub fn build(
self,
) -> Result<crate::input::ListDatastoresInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListDatastoresInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListDatastoresInput {
/// Consumes the builder and constructs an Operation<[`ListDatastores`](crate::operation::ListDatastores)>
#[allow(unused_mut)]
#[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::ListDatastores,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListDatastoresInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/datastores").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListDatastoresInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_25) = &_input.next_token {
{
query.push_kv("nextToken", &aws_smithy_http::query::fmt_string(&inner_25));
}
}
if let Some(inner_26) = &_input.max_results {
if *inner_26 != 0 {
query.push_kv(
"maxResults",
aws_smithy_types::primitive::Encoder::from(*inner_26).encode(),
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListDatastoresInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListDatastores::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListDatastores",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListDatastoresInput`](crate::input::ListDatastoresInput).
pub fn builder() -> crate::input::list_datastores_input::Builder {
crate::input::list_datastores_input::Builder::default()
}
}
/// See [`ListPipelinesInput`](crate::input::ListPipelinesInput).
pub mod list_pipelines_input {
/// A builder for [`ListPipelinesInput`](crate::input::ListPipelinesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
/// <p>The token for the next set of results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>The token for the next set of results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// Consumes the builder and constructs a [`ListPipelinesInput`](crate::input::ListPipelinesInput).
pub fn build(
self,
) -> Result<crate::input::ListPipelinesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListPipelinesInput {
next_token: self.next_token,
max_results: self.max_results,
})
}
}
}
impl ListPipelinesInput {
/// Consumes the builder and constructs an Operation<[`ListPipelines`](crate::operation::ListPipelines)>
#[allow(unused_mut)]
#[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::ListPipelines,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListPipelinesInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/pipelines").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListPipelinesInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_27) = &_input.next_token {
{
query.push_kv("nextToken", &aws_smithy_http::query::fmt_string(&inner_27));
}
}
if let Some(inner_28) = &_input.max_results {
if *inner_28 != 0 {
query.push_kv(
"maxResults",
aws_smithy_types::primitive::Encoder::from(*inner_28).encode(),
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListPipelinesInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListPipelines::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListPipelines",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListPipelinesInput`](crate::input::ListPipelinesInput).
pub fn builder() -> crate::input::list_pipelines_input::Builder {
crate::input::list_pipelines_input::Builder::default()
}
}
/// See [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub mod list_tags_for_resource_input {
/// A builder for [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ARN of the resource whose tags you want to list.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the resource whose tags you want to list.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Consumes the builder and constructs a [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub fn build(
self,
) -> Result<
crate::input::ListTagsForResourceInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListTagsForResourceInput {
resource_arn: self.resource_arn,
})
}
}
}
impl ListTagsForResourceInput {
/// Consumes the builder and constructs an Operation<[`ListTagsForResource`](crate::operation::ListTagsForResource)>
#[allow(unused_mut)]
#[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::ListTagsForResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListTagsForResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/tags").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::ListTagsForResourceInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
let inner_29 = &_input.resource_arn;
let inner_29 = inner_29.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
)
})?;
if inner_29.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
),
);
}
query.push_kv(
"resourceArn",
&aws_smithy_http::query::fmt_string(&inner_29),
);
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListTagsForResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListTagsForResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListTagsForResource",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
crate::input::list_tags_for_resource_input::Builder::default()
}
}
/// See [`PutLoggingOptionsInput`](crate::input::PutLoggingOptionsInput).
pub mod put_logging_options_input {
/// A builder for [`PutLoggingOptionsInput`](crate::input::PutLoggingOptionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) logging_options: std::option::Option<crate::model::LoggingOptions>,
}
impl Builder {
/// <p>The new values of the IoT Analytics logging options.</p>
pub fn logging_options(mut self, input: crate::model::LoggingOptions) -> Self {
self.logging_options = Some(input);
self
}
/// <p>The new values of the IoT Analytics logging options.</p>
pub fn set_logging_options(
mut self,
input: std::option::Option<crate::model::LoggingOptions>,
) -> Self {
self.logging_options = input;
self
}
/// Consumes the builder and constructs a [`PutLoggingOptionsInput`](crate::input::PutLoggingOptionsInput).
pub fn build(
self,
) -> Result<
crate::input::PutLoggingOptionsInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::PutLoggingOptionsInput {
logging_options: self.logging_options,
})
}
}
}
impl PutLoggingOptionsInput {
/// Consumes the builder and constructs an Operation<[`PutLoggingOptions`](crate::operation::PutLoggingOptions)>
#[allow(unused_mut)]
#[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::PutLoggingOptions,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::PutLoggingOptionsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/logging").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutLoggingOptionsInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("PUT").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_put_logging_options(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::PutLoggingOptions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutLoggingOptions",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutLoggingOptionsInput`](crate::input::PutLoggingOptionsInput).
pub fn builder() -> crate::input::put_logging_options_input::Builder {
crate::input::put_logging_options_input::Builder::default()
}
}
/// See [`RunPipelineActivityInput`](crate::input::RunPipelineActivityInput).
pub mod run_pipeline_activity_input {
/// A builder for [`RunPipelineActivityInput`](crate::input::RunPipelineActivityInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_activity: std::option::Option<crate::model::PipelineActivity>,
pub(crate) payloads: std::option::Option<std::vec::Vec<aws_smithy_types::Blob>>,
}
impl Builder {
/// <p>The pipeline activity that is run. This must not be a channel activity or a data store activity because these activities are used in a pipeline only to load the original message and to store the (possibly) transformed message. If a Lambda activity is specified, only short-running Lambda functions (those with a timeout of less than 30 seconds or less) can be used.</p>
pub fn pipeline_activity(mut self, input: crate::model::PipelineActivity) -> Self {
self.pipeline_activity = Some(input);
self
}
/// <p>The pipeline activity that is run. This must not be a channel activity or a data store activity because these activities are used in a pipeline only to load the original message and to store the (possibly) transformed message. If a Lambda activity is specified, only short-running Lambda functions (those with a timeout of less than 30 seconds or less) can be used.</p>
pub fn set_pipeline_activity(
mut self,
input: std::option::Option<crate::model::PipelineActivity>,
) -> Self {
self.pipeline_activity = input;
self
}
/// Appends an item to `payloads`.
///
/// To override the contents of this collection use [`set_payloads`](Self::set_payloads).
///
/// <p>The sample message payloads on which the pipeline activity is run.</p>
pub fn payloads(mut self, input: aws_smithy_types::Blob) -> Self {
let mut v = self.payloads.unwrap_or_default();
v.push(input);
self.payloads = Some(v);
self
}
/// <p>The sample message payloads on which the pipeline activity is run.</p>
pub fn set_payloads(
mut self,
input: std::option::Option<std::vec::Vec<aws_smithy_types::Blob>>,
) -> Self {
self.payloads = input;
self
}
/// Consumes the builder and constructs a [`RunPipelineActivityInput`](crate::input::RunPipelineActivityInput).
pub fn build(
self,
) -> Result<
crate::input::RunPipelineActivityInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::RunPipelineActivityInput {
pipeline_activity: self.pipeline_activity,
payloads: self.payloads,
})
}
}
}
impl RunPipelineActivityInput {
/// Consumes the builder and constructs an Operation<[`RunPipelineActivity`](crate::operation::RunPipelineActivity)>
#[allow(unused_mut)]
#[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::RunPipelineActivity,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::RunPipelineActivityInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/pipelineactivities/run").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RunPipelineActivityInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_run_pipeline_activity(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::RunPipelineActivity::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RunPipelineActivity",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RunPipelineActivityInput`](crate::input::RunPipelineActivityInput).
pub fn builder() -> crate::input::run_pipeline_activity_input::Builder {
crate::input::run_pipeline_activity_input::Builder::default()
}
}
/// See [`SampleChannelDataInput`](crate::input::SampleChannelDataInput).
pub mod sample_channel_data_input {
/// A builder for [`SampleChannelDataInput`](crate::input::SampleChannelDataInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
pub(crate) max_messages: std::option::Option<i32>,
pub(crate) start_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) end_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The name of the channel whose message samples are retrieved.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel whose message samples are retrieved.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// <p>The number of sample messages to be retrieved. The limit is 10. The default is also 10.</p>
pub fn max_messages(mut self, input: i32) -> Self {
self.max_messages = Some(input);
self
}
/// <p>The number of sample messages to be retrieved. The limit is 10. The default is also 10.</p>
pub fn set_max_messages(mut self, input: std::option::Option<i32>) -> Self {
self.max_messages = input;
self
}
/// <p>The start of the time window from which sample messages are retrieved.</p>
pub fn start_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.start_time = Some(input);
self
}
/// <p>The start of the time window from which sample messages are retrieved.</p>
pub fn set_start_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.start_time = input;
self
}
/// <p>The end of the time window from which sample messages are retrieved.</p>
pub fn end_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.end_time = Some(input);
self
}
/// <p>The end of the time window from which sample messages are retrieved.</p>
pub fn set_end_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.end_time = input;
self
}
/// Consumes the builder and constructs a [`SampleChannelDataInput`](crate::input::SampleChannelDataInput).
pub fn build(
self,
) -> Result<
crate::input::SampleChannelDataInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::SampleChannelDataInput {
channel_name: self.channel_name,
max_messages: self.max_messages,
start_time: self.start_time,
end_time: self.end_time,
})
}
}
}
impl SampleChannelDataInput {
/// Consumes the builder and constructs an Operation<[`SampleChannelData`](crate::operation::SampleChannelData)>
#[allow(unused_mut)]
#[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::SampleChannelData,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::SampleChannelDataInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_30 = &_input.channel_name;
let input_30 = input_30.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
)
})?;
let channel_name = aws_smithy_http::label::fmt_string(
input_30,
aws_smithy_http::label::EncodingStrategy::Default,
);
if channel_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/channels/{channelName}/sample",
channelName = channel_name
)
.expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::SampleChannelDataInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
if let Some(inner_31) = &_input.max_messages {
if *inner_31 != 0 {
query.push_kv(
"maxMessages",
aws_smithy_types::primitive::Encoder::from(*inner_31).encode(),
);
}
}
if let Some(inner_32) = &_input.start_time {
{
query.push_kv(
"startTime",
&aws_smithy_http::query::fmt_timestamp(
inner_32,
aws_smithy_types::date_time::Format::DateTime,
)?,
);
}
}
if let Some(inner_33) = &_input.end_time {
{
query.push_kv(
"endTime",
&aws_smithy_http::query::fmt_timestamp(
inner_33,
aws_smithy_types::date_time::Format::DateTime,
)?,
);
}
}
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SampleChannelDataInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SampleChannelData::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SampleChannelData",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`SampleChannelDataInput`](crate::input::SampleChannelDataInput).
pub fn builder() -> crate::input::sample_channel_data_input::Builder {
crate::input::sample_channel_data_input::Builder::default()
}
}
/// See [`StartPipelineReprocessingInput`](crate::input::StartPipelineReprocessingInput).
pub mod start_pipeline_reprocessing_input {
/// A builder for [`StartPipelineReprocessingInput`](crate::input::StartPipelineReprocessingInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
pub(crate) start_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) end_time: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) channel_messages: std::option::Option<crate::model::ChannelMessages>,
}
impl Builder {
/// <p>The name of the pipeline on which to start reprocessing.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of the pipeline on which to start reprocessing.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// <p>The start time (inclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>startTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn start_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.start_time = Some(input);
self
}
/// <p>The start time (inclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>startTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn set_start_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.start_time = input;
self
}
/// <p>The end time (exclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>endTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn end_time(mut self, input: aws_smithy_types::DateTime) -> Self {
self.end_time = Some(input);
self
}
/// <p>The end time (exclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>endTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn set_end_time(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.end_time = input;
self
}
/// <p>Specifies one or more sets of channel messages that you want to reprocess.</p>
/// <p>If you use the <code>channelMessages</code> object, you must not specify a value for <code>startTime</code> and <code>endTime</code>.</p>
pub fn channel_messages(mut self, input: crate::model::ChannelMessages) -> Self {
self.channel_messages = Some(input);
self
}
/// <p>Specifies one or more sets of channel messages that you want to reprocess.</p>
/// <p>If you use the <code>channelMessages</code> object, you must not specify a value for <code>startTime</code> and <code>endTime</code>.</p>
pub fn set_channel_messages(
mut self,
input: std::option::Option<crate::model::ChannelMessages>,
) -> Self {
self.channel_messages = input;
self
}
/// Consumes the builder and constructs a [`StartPipelineReprocessingInput`](crate::input::StartPipelineReprocessingInput).
pub fn build(
self,
) -> Result<
crate::input::StartPipelineReprocessingInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartPipelineReprocessingInput {
pipeline_name: self.pipeline_name,
start_time: self.start_time,
end_time: self.end_time,
channel_messages: self.channel_messages,
})
}
}
}
impl StartPipelineReprocessingInput {
/// Consumes the builder and constructs an Operation<[`StartPipelineReprocessing`](crate::operation::StartPipelineReprocessing)>
#[allow(unused_mut)]
#[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::StartPipelineReprocessing,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::StartPipelineReprocessingInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_34 = &_input.pipeline_name;
let input_34 = input_34.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
)
})?;
let pipeline_name = aws_smithy_http::label::fmt_string(
input_34,
aws_smithy_http::label::EncodingStrategy::Default,
);
if pipeline_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/pipelines/{pipelineName}/reprocessing",
pipelineName = pipeline_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartPipelineReprocessingInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_start_pipeline_reprocessing(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartPipelineReprocessing::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartPipelineReprocessing",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartPipelineReprocessingInput`](crate::input::StartPipelineReprocessingInput).
pub fn builder() -> crate::input::start_pipeline_reprocessing_input::Builder {
crate::input::start_pipeline_reprocessing_input::Builder::default()
}
}
/// See [`TagResourceInput`](crate::input::TagResourceInput).
pub mod tag_resource_input {
/// A builder for [`TagResourceInput`](crate::input::TagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The ARN of the resource whose tags you want to modify.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the resource whose tags you want to modify.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>The new or modified tags for the resource.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>The new or modified tags for the resource.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`TagResourceInput`](crate::input::TagResourceInput).
pub fn build(
self,
) -> Result<crate::input::TagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::TagResourceInput {
resource_arn: self.resource_arn,
tags: self.tags,
})
}
}
}
impl TagResourceInput {
/// Consumes the builder and constructs an Operation<[`TagResource`](crate::operation::TagResource)>
#[allow(unused_mut)]
#[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::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::TagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/tags").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::TagResourceInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
let inner_35 = &_input.resource_arn;
let inner_35 = inner_35.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
)
})?;
if inner_35.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
),
);
}
query.push_kv(
"resourceArn",
&aws_smithy_http::query::fmt_string(&inner_35),
);
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::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("POST").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_tag_resource(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::TagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"TagResource",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput).
pub fn builder() -> crate::input::tag_resource_input::Builder {
crate::input::tag_resource_input::Builder::default()
}
}
/// See [`UntagResourceInput`](crate::input::UntagResourceInput).
pub mod untag_resource_input {
/// A builder for [`UntagResourceInput`](crate::input::UntagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_arn: std::option::Option<std::string::String>,
pub(crate) tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The ARN of the resource whose tags you want to remove.</p>
pub fn resource_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_arn = Some(input.into());
self
}
/// <p>The ARN of the resource whose tags you want to remove.</p>
pub fn set_resource_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource_arn = input;
self
}
/// Appends an item to `tag_keys`.
///
/// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
///
/// <p>The keys of those tags which you want to remove.</p>
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
}
/// <p>The keys of those tags which you want to remove.</p>
pub fn set_tag_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tag_keys = input;
self
}
/// Consumes the builder and constructs a [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn build(
self,
) -> Result<crate::input::UntagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UntagResourceInput {
resource_arn: self.resource_arn,
tag_keys: self.tag_keys,
})
}
}
}
impl UntagResourceInput {
/// Consumes the builder and constructs an Operation<[`UntagResource`](crate::operation::UntagResource)>
#[allow(unused_mut)]
#[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::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UntagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/tags").expect("formatting should succeed");
Ok(())
}
fn uri_query(
_input: &crate::input::UntagResourceInput,
mut output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let mut query = aws_smithy_http::query::Writer::new(&mut output);
let inner_36 = &_input.resource_arn;
let inner_36 = inner_36.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
)
})?;
if inner_36.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"resource_arn",
"cannot be empty or unset",
),
);
}
query.push_kv(
"resourceArn",
&aws_smithy_http::query::fmt_string(&inner_36),
);
let inner_37 = &_input.tag_keys;
let inner_37 = inner_37.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"tag_keys",
"cannot be empty or unset",
)
})?;
for inner_38 in inner_37 {
query.push_kv("tagKeys", &aws_smithy_http::query::fmt_string(&inner_38));
}
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::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
Ok(builder.method("DELETE").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UntagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UntagResource",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn builder() -> crate::input::untag_resource_input::Builder {
crate::input::untag_resource_input::Builder::default()
}
}
/// See [`UpdateChannelInput`](crate::input::UpdateChannelInput).
pub mod update_channel_input {
/// A builder for [`UpdateChannelInput`](crate::input::UpdateChannelInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) channel_name: std::option::Option<std::string::String>,
pub(crate) channel_storage: std::option::Option<crate::model::ChannelStorage>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
}
impl Builder {
/// <p>The name of the channel to be updated.</p>
pub fn channel_name(mut self, input: impl Into<std::string::String>) -> Self {
self.channel_name = Some(input.into());
self
}
/// <p>The name of the channel to be updated.</p>
pub fn set_channel_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.channel_name = input;
self
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn channel_storage(mut self, input: crate::model::ChannelStorage) -> Self {
self.channel_storage = Some(input);
self
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn set_channel_storage(
mut self,
input: std::option::Option<crate::model::ChannelStorage>,
) -> Self {
self.channel_storage = input;
self
}
/// <p>How long, in days, message data is kept for the channel. The retention period can't be updated if the channel's Amazon S3 storage is customer-managed.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>How long, in days, message data is kept for the channel. The retention period can't be updated if the channel's Amazon S3 storage is customer-managed.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// Consumes the builder and constructs a [`UpdateChannelInput`](crate::input::UpdateChannelInput).
pub fn build(
self,
) -> Result<crate::input::UpdateChannelInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateChannelInput {
channel_name: self.channel_name,
channel_storage: self.channel_storage,
retention_period: self.retention_period,
})
}
}
}
impl UpdateChannelInput {
/// Consumes the builder and constructs an Operation<[`UpdateChannel`](crate::operation::UpdateChannel)>
#[allow(unused_mut)]
#[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::UpdateChannel,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateChannelInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_39 = &_input.channel_name;
let input_39 = input_39.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
)
})?;
let channel_name = aws_smithy_http::label::fmt_string(
input_39,
aws_smithy_http::label::EncodingStrategy::Default,
);
if channel_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"channel_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/channels/{channelName}",
channelName = channel_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateChannelInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("PUT").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_channel(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateChannel::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateChannel",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateChannelInput`](crate::input::UpdateChannelInput).
pub fn builder() -> crate::input::update_channel_input::Builder {
crate::input::update_channel_input::Builder::default()
}
}
/// See [`UpdateDatasetInput`](crate::input::UpdateDatasetInput).
pub mod update_dataset_input {
/// A builder for [`UpdateDatasetInput`](crate::input::UpdateDatasetInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) dataset_name: std::option::Option<std::string::String>,
pub(crate) actions: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
pub(crate) triggers: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
pub(crate) content_delivery_rules:
std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
pub(crate) versioning_configuration:
std::option::Option<crate::model::VersioningConfiguration>,
pub(crate) late_data_rules: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
}
impl Builder {
/// <p>The name of the dataset to update.</p>
pub fn dataset_name(mut self, input: impl Into<std::string::String>) -> Self {
self.dataset_name = Some(input.into());
self
}
/// <p>The name of the dataset to update.</p>
pub fn set_dataset_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.dataset_name = input;
self
}
/// Appends an item to `actions`.
///
/// To override the contents of this collection use [`set_actions`](Self::set_actions).
///
/// <p>A list of <code>DatasetAction</code> objects.</p>
pub fn actions(mut self, input: crate::model::DatasetAction) -> Self {
let mut v = self.actions.unwrap_or_default();
v.push(input);
self.actions = Some(v);
self
}
/// <p>A list of <code>DatasetAction</code> objects.</p>
pub fn set_actions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
) -> Self {
self.actions = input;
self
}
/// Appends an item to `triggers`.
///
/// To override the contents of this collection use [`set_triggers`](Self::set_triggers).
///
/// <p>A list of <code>DatasetTrigger</code> objects. The list can be empty or can contain up to five <code>DatasetTrigger</code> objects.</p>
pub fn triggers(mut self, input: crate::model::DatasetTrigger) -> Self {
let mut v = self.triggers.unwrap_or_default();
v.push(input);
self.triggers = Some(v);
self
}
/// <p>A list of <code>DatasetTrigger</code> objects. The list can be empty or can contain up to five <code>DatasetTrigger</code> objects.</p>
pub fn set_triggers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
) -> Self {
self.triggers = input;
self
}
/// Appends an item to `content_delivery_rules`.
///
/// To override the contents of this collection use [`set_content_delivery_rules`](Self::set_content_delivery_rules).
///
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn content_delivery_rules(
mut self,
input: crate::model::DatasetContentDeliveryRule,
) -> Self {
let mut v = self.content_delivery_rules.unwrap_or_default();
v.push(input);
self.content_delivery_rules = Some(v);
self
}
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn set_content_delivery_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
) -> Self {
self.content_delivery_rules = input;
self
}
/// <p>How long, in days, dataset contents are kept for the dataset.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>How long, in days, dataset contents are kept for the dataset.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn versioning_configuration(
mut self,
input: crate::model::VersioningConfiguration,
) -> Self {
self.versioning_configuration = Some(input);
self
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn set_versioning_configuration(
mut self,
input: std::option::Option<crate::model::VersioningConfiguration>,
) -> Self {
self.versioning_configuration = input;
self
}
/// Appends an item to `late_data_rules`.
///
/// To override the contents of this collection use [`set_late_data_rules`](Self::set_late_data_rules).
///
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn late_data_rules(mut self, input: crate::model::LateDataRule) -> Self {
let mut v = self.late_data_rules.unwrap_or_default();
v.push(input);
self.late_data_rules = Some(v);
self
}
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn set_late_data_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
) -> Self {
self.late_data_rules = input;
self
}
/// Consumes the builder and constructs a [`UpdateDatasetInput`](crate::input::UpdateDatasetInput).
pub fn build(
self,
) -> Result<crate::input::UpdateDatasetInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateDatasetInput {
dataset_name: self.dataset_name,
actions: self.actions,
triggers: self.triggers,
content_delivery_rules: self.content_delivery_rules,
retention_period: self.retention_period,
versioning_configuration: self.versioning_configuration,
late_data_rules: self.late_data_rules,
})
}
}
}
impl UpdateDatasetInput {
/// Consumes the builder and constructs an Operation<[`UpdateDataset`](crate::operation::UpdateDataset)>
#[allow(unused_mut)]
#[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::UpdateDataset,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateDatasetInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_40 = &_input.dataset_name;
let input_40 = input_40.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
)
})?;
let dataset_name = aws_smithy_http::label::fmt_string(
input_40,
aws_smithy_http::label::EncodingStrategy::Default,
);
if dataset_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"dataset_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datasets/{datasetName}",
datasetName = dataset_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDatasetInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("PUT").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_dataset(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDataset::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDataset",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateDatasetInput`](crate::input::UpdateDatasetInput).
pub fn builder() -> crate::input::update_dataset_input::Builder {
crate::input::update_dataset_input::Builder::default()
}
}
/// See [`UpdateDatastoreInput`](crate::input::UpdateDatastoreInput).
pub mod update_datastore_input {
/// A builder for [`UpdateDatastoreInput`](crate::input::UpdateDatastoreInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) datastore_name: std::option::Option<std::string::String>,
pub(crate) retention_period: std::option::Option<crate::model::RetentionPeriod>,
pub(crate) datastore_storage: std::option::Option<crate::model::DatastoreStorage>,
pub(crate) file_format_configuration:
std::option::Option<crate::model::FileFormatConfiguration>,
}
impl Builder {
/// <p>The name of the data store to be updated.</p>
pub fn datastore_name(mut self, input: impl Into<std::string::String>) -> Self {
self.datastore_name = Some(input.into());
self
}
/// <p>The name of the data store to be updated.</p>
pub fn set_datastore_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.datastore_name = input;
self
}
/// <p>How long, in days, message data is kept for the data store. The retention period can't be updated if the data store's Amazon S3 storage is customer-managed.</p>
pub fn retention_period(mut self, input: crate::model::RetentionPeriod) -> Self {
self.retention_period = Some(input);
self
}
/// <p>How long, in days, message data is kept for the data store. The retention period can't be updated if the data store's Amazon S3 storage is customer-managed.</p>
pub fn set_retention_period(
mut self,
input: std::option::Option<crate::model::RetentionPeriod>,
) -> Self {
self.retention_period = input;
self
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn datastore_storage(mut self, input: crate::model::DatastoreStorage) -> Self {
self.datastore_storage = Some(input);
self
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn set_datastore_storage(
mut self,
input: std::option::Option<crate::model::DatastoreStorage>,
) -> Self {
self.datastore_storage = input;
self
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn file_format_configuration(
mut self,
input: crate::model::FileFormatConfiguration,
) -> Self {
self.file_format_configuration = Some(input);
self
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn set_file_format_configuration(
mut self,
input: std::option::Option<crate::model::FileFormatConfiguration>,
) -> Self {
self.file_format_configuration = input;
self
}
/// Consumes the builder and constructs a [`UpdateDatastoreInput`](crate::input::UpdateDatastoreInput).
pub fn build(
self,
) -> Result<crate::input::UpdateDatastoreInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateDatastoreInput {
datastore_name: self.datastore_name,
retention_period: self.retention_period,
datastore_storage: self.datastore_storage,
file_format_configuration: self.file_format_configuration,
})
}
}
}
impl UpdateDatastoreInput {
/// Consumes the builder and constructs an Operation<[`UpdateDatastore`](crate::operation::UpdateDatastore)>
#[allow(unused_mut)]
#[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::UpdateDatastore,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdateDatastoreInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_41 = &_input.datastore_name;
let input_41 = input_41.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
)
})?;
let datastore_name = aws_smithy_http::label::fmt_string(
input_41,
aws_smithy_http::label::EncodingStrategy::Default,
);
if datastore_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"datastore_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/datastores/{datastoreName}",
datastoreName = datastore_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateDatastoreInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("PUT").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_datastore(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateDatastore::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateDatastore",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateDatastoreInput`](crate::input::UpdateDatastoreInput).
pub fn builder() -> crate::input::update_datastore_input::Builder {
crate::input::update_datastore_input::Builder::default()
}
}
/// See [`UpdatePipelineInput`](crate::input::UpdatePipelineInput).
pub mod update_pipeline_input {
/// A builder for [`UpdatePipelineInput`](crate::input::UpdatePipelineInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) pipeline_name: std::option::Option<std::string::String>,
pub(crate) pipeline_activities:
std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
}
impl Builder {
/// <p>The name of the pipeline to update.</p>
pub fn pipeline_name(mut self, input: impl Into<std::string::String>) -> Self {
self.pipeline_name = Some(input.into());
self
}
/// <p>The name of the pipeline to update.</p>
pub fn set_pipeline_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pipeline_name = input;
self
}
/// Appends an item to `pipeline_activities`.
///
/// To override the contents of this collection use [`set_pipeline_activities`](Self::set_pipeline_activities).
///
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda functions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn pipeline_activities(mut self, input: crate::model::PipelineActivity) -> Self {
let mut v = self.pipeline_activities.unwrap_or_default();
v.push(input);
self.pipeline_activities = Some(v);
self
}
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda functions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn set_pipeline_activities(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
) -> Self {
self.pipeline_activities = input;
self
}
/// Consumes the builder and constructs a [`UpdatePipelineInput`](crate::input::UpdatePipelineInput).
pub fn build(
self,
) -> Result<crate::input::UpdatePipelineInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdatePipelineInput {
pipeline_name: self.pipeline_name,
pipeline_activities: self.pipeline_activities,
})
}
}
}
impl UpdatePipelineInput {
/// Consumes the builder and constructs an Operation<[`UpdatePipeline`](crate::operation::UpdatePipeline)>
#[allow(unused_mut)]
#[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::UpdatePipeline,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UpdatePipelineInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
let input_42 = &_input.pipeline_name;
let input_42 = input_42.as_ref().ok_or_else(|| {
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
)
})?;
let pipeline_name = aws_smithy_http::label::fmt_string(
input_42,
aws_smithy_http::label::EncodingStrategy::Default,
);
if pipeline_name.is_empty() {
return Err(
aws_smithy_http::operation::error::BuildError::missing_field(
"pipeline_name",
"cannot be empty or unset",
),
);
}
write!(
output,
"/pipelines/{pipelineName}",
pipelineName = pipeline_name
)
.expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdatePipelineInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
Ok(builder.method("PUT").uri(uri))
}
let mut builder = update_http_builder(&self, http::request::Builder::new())?;
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::CONTENT_TYPE,
"application/json",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_update_pipeline(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
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);
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(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdatePipeline::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdatePipeline",
"iotanalytics",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdatePipelineInput`](crate::input::UpdatePipelineInput).
pub fn builder() -> crate::input::update_pipeline_input::Builder {
crate::input::update_pipeline_input::Builder::default()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdatePipelineInput {
/// <p>The name of the pipeline to update.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda functions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
#[doc(hidden)]
pub pipeline_activities: std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
}
impl UpdatePipelineInput {
/// <p>The name of the pipeline to update.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda functions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn pipeline_activities(&self) -> std::option::Option<&[crate::model::PipelineActivity]> {
self.pipeline_activities.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDatastoreInput {
/// <p>The name of the data store to be updated.</p>
#[doc(hidden)]
pub datastore_name: std::option::Option<std::string::String>,
/// <p>How long, in days, message data is kept for the data store. The retention period can't be updated if the data store's Amazon S3 storage is customer-managed.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
#[doc(hidden)]
pub datastore_storage: std::option::Option<crate::model::DatastoreStorage>,
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
#[doc(hidden)]
pub file_format_configuration: std::option::Option<crate::model::FileFormatConfiguration>,
}
impl UpdateDatastoreInput {
/// <p>The name of the data store to be updated.</p>
pub fn datastore_name(&self) -> std::option::Option<&str> {
self.datastore_name.as_deref()
}
/// <p>How long, in days, message data is kept for the data store. The retention period can't be updated if the data store's Amazon S3 storage is customer-managed.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn datastore_storage(&self) -> std::option::Option<&crate::model::DatastoreStorage> {
self.datastore_storage.as_ref()
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn file_format_configuration(
&self,
) -> std::option::Option<&crate::model::FileFormatConfiguration> {
self.file_format_configuration.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDatasetInput {
/// <p>The name of the dataset to update.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>A list of <code>DatasetAction</code> objects.</p>
#[doc(hidden)]
pub actions: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
/// <p>A list of <code>DatasetTrigger</code> objects. The list can be empty or can contain up to five <code>DatasetTrigger</code> objects.</p>
#[doc(hidden)]
pub triggers: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
#[doc(hidden)]
pub content_delivery_rules:
std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
/// <p>How long, in days, dataset contents are kept for the dataset.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
#[doc(hidden)]
pub versioning_configuration: std::option::Option<crate::model::VersioningConfiguration>,
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
#[doc(hidden)]
pub late_data_rules: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
}
impl UpdateDatasetInput {
/// <p>The name of the dataset to update.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>A list of <code>DatasetAction</code> objects.</p>
pub fn actions(&self) -> std::option::Option<&[crate::model::DatasetAction]> {
self.actions.as_deref()
}
/// <p>A list of <code>DatasetTrigger</code> objects. The list can be empty or can contain up to five <code>DatasetTrigger</code> objects.</p>
pub fn triggers(&self) -> std::option::Option<&[crate::model::DatasetTrigger]> {
self.triggers.as_deref()
}
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn content_delivery_rules(
&self,
) -> std::option::Option<&[crate::model::DatasetContentDeliveryRule]> {
self.content_delivery_rules.as_deref()
}
/// <p>How long, in days, dataset contents are kept for the dataset.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn versioning_configuration(
&self,
) -> std::option::Option<&crate::model::VersioningConfiguration> {
self.versioning_configuration.as_ref()
}
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn late_data_rules(&self) -> std::option::Option<&[crate::model::LateDataRule]> {
self.late_data_rules.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateChannelInput {
/// <p>The name of the channel to be updated.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
#[doc(hidden)]
pub channel_storage: std::option::Option<crate::model::ChannelStorage>,
/// <p>How long, in days, message data is kept for the channel. The retention period can't be updated if the channel's Amazon S3 storage is customer-managed.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
}
impl UpdateChannelInput {
/// <p>The name of the channel to be updated.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn channel_storage(&self) -> std::option::Option<&crate::model::ChannelStorage> {
self.channel_storage.as_ref()
}
/// <p>How long, in days, message data is kept for the channel. The retention period can't be updated if the channel's Amazon S3 storage is customer-managed.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceInput {
/// <p>The ARN of the resource whose tags you want to remove.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
/// <p>The keys of those tags which you want to remove.</p>
#[doc(hidden)]
pub tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UntagResourceInput {
/// <p>The ARN of the resource whose tags you want to remove.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
/// <p>The keys of those tags which you want to remove.</p>
pub fn tag_keys(&self) -> std::option::Option<&[std::string::String]> {
self.tag_keys.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagResourceInput {
/// <p>The ARN of the resource whose tags you want to modify.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
/// <p>The new or modified tags for the resource.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl TagResourceInput {
/// <p>The ARN of the resource whose tags you want to modify.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
/// <p>The new or modified tags for the resource.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartPipelineReprocessingInput {
/// <p>The name of the pipeline on which to start reprocessing.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
/// <p>The start time (inclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>startTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
#[doc(hidden)]
pub start_time: std::option::Option<aws_smithy_types::DateTime>,
/// <p>The end time (exclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>endTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
#[doc(hidden)]
pub end_time: std::option::Option<aws_smithy_types::DateTime>,
/// <p>Specifies one or more sets of channel messages that you want to reprocess.</p>
/// <p>If you use the <code>channelMessages</code> object, you must not specify a value for <code>startTime</code> and <code>endTime</code>.</p>
#[doc(hidden)]
pub channel_messages: std::option::Option<crate::model::ChannelMessages>,
}
impl StartPipelineReprocessingInput {
/// <p>The name of the pipeline on which to start reprocessing.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
/// <p>The start time (inclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>startTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn start_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.start_time.as_ref()
}
/// <p>The end time (exclusive) of raw message data that is reprocessed.</p>
/// <p>If you specify a value for the <code>endTime</code> parameter, you must not use the <code>channelMessages</code> object.</p>
pub fn end_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.end_time.as_ref()
}
/// <p>Specifies one or more sets of channel messages that you want to reprocess.</p>
/// <p>If you use the <code>channelMessages</code> object, you must not specify a value for <code>startTime</code> and <code>endTime</code>.</p>
pub fn channel_messages(&self) -> std::option::Option<&crate::model::ChannelMessages> {
self.channel_messages.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SampleChannelDataInput {
/// <p>The name of the channel whose message samples are retrieved.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
/// <p>The number of sample messages to be retrieved. The limit is 10. The default is also 10.</p>
#[doc(hidden)]
pub max_messages: std::option::Option<i32>,
/// <p>The start of the time window from which sample messages are retrieved.</p>
#[doc(hidden)]
pub start_time: std::option::Option<aws_smithy_types::DateTime>,
/// <p>The end of the time window from which sample messages are retrieved.</p>
#[doc(hidden)]
pub end_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl SampleChannelDataInput {
/// <p>The name of the channel whose message samples are retrieved.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
/// <p>The number of sample messages to be retrieved. The limit is 10. The default is also 10.</p>
pub fn max_messages(&self) -> std::option::Option<i32> {
self.max_messages
}
/// <p>The start of the time window from which sample messages are retrieved.</p>
pub fn start_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.start_time.as_ref()
}
/// <p>The end of the time window from which sample messages are retrieved.</p>
pub fn end_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.end_time.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RunPipelineActivityInput {
/// <p>The pipeline activity that is run. This must not be a channel activity or a data store activity because these activities are used in a pipeline only to load the original message and to store the (possibly) transformed message. If a Lambda activity is specified, only short-running Lambda functions (those with a timeout of less than 30 seconds or less) can be used.</p>
#[doc(hidden)]
pub pipeline_activity: std::option::Option<crate::model::PipelineActivity>,
/// <p>The sample message payloads on which the pipeline activity is run.</p>
#[doc(hidden)]
pub payloads: std::option::Option<std::vec::Vec<aws_smithy_types::Blob>>,
}
impl RunPipelineActivityInput {
/// <p>The pipeline activity that is run. This must not be a channel activity or a data store activity because these activities are used in a pipeline only to load the original message and to store the (possibly) transformed message. If a Lambda activity is specified, only short-running Lambda functions (those with a timeout of less than 30 seconds or less) can be used.</p>
pub fn pipeline_activity(&self) -> std::option::Option<&crate::model::PipelineActivity> {
self.pipeline_activity.as_ref()
}
/// <p>The sample message payloads on which the pipeline activity is run.</p>
pub fn payloads(&self) -> std::option::Option<&[aws_smithy_types::Blob]> {
self.payloads.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutLoggingOptionsInput {
/// <p>The new values of the IoT Analytics logging options.</p>
#[doc(hidden)]
pub logging_options: std::option::Option<crate::model::LoggingOptions>,
}
impl PutLoggingOptionsInput {
/// <p>The new values of the IoT Analytics logging options.</p>
pub fn logging_options(&self) -> std::option::Option<&crate::model::LoggingOptions> {
self.logging_options.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceInput {
/// <p>The ARN of the resource whose tags you want to list.</p>
#[doc(hidden)]
pub resource_arn: std::option::Option<std::string::String>,
}
impl ListTagsForResourceInput {
/// <p>The ARN of the resource whose tags you want to list.</p>
pub fn resource_arn(&self) -> std::option::Option<&str> {
self.resource_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListPipelinesInput {
/// <p>The token for the next set of results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListPipelinesInput {
/// <p>The token for the next set of results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDatastoresInput {
/// <p>The token for the next set of results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListDatastoresInput {
/// <p>The token for the next set of results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDatasetsInput {
/// <p>The token for the next set of results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListDatasetsInput {
/// <p>The token for the next set of results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDatasetContentsInput {
/// <p>The name of the dataset whose contents information you want to list.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>The token for the next set of results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return in this request.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>A filter to limit results to those dataset contents whose creation is scheduled on or after the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
#[doc(hidden)]
pub scheduled_on_or_after: std::option::Option<aws_smithy_types::DateTime>,
/// <p>A filter to limit results to those dataset contents whose creation is scheduled before the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
#[doc(hidden)]
pub scheduled_before: std::option::Option<aws_smithy_types::DateTime>,
}
impl ListDatasetContentsInput {
/// <p>The name of the dataset whose contents information you want to list.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>The token for the next set of results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return in this request.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled on or after the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn scheduled_on_or_after(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.scheduled_on_or_after.as_ref()
}
/// <p>A filter to limit results to those dataset contents whose creation is scheduled before the given time. See the field <code>triggers.schedule</code> in the <code>CreateDataset</code> request. (timestamp)</p>
pub fn scheduled_before(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.scheduled_before.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListChannelsInput {
/// <p>The token for the next set of results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
}
impl ListChannelsInput {
/// <p>The token for the next set of results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of results to return in this request.</p>
/// <p>The default value is 100.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDatasetContentInput {
/// <p>The name of the dataset whose contents are retrieved.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>The version of the dataset whose contents are retrieved. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest or latest successfully completed dataset. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl GetDatasetContentInput {
/// <p>The name of the dataset whose contents are retrieved.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>The version of the dataset whose contents are retrieved. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to retrieve the contents of the latest or latest successfully completed dataset. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribePipelineInput {
/// <p>The name of the pipeline whose information is retrieved.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
}
impl DescribePipelineInput {
/// <p>The name of the pipeline whose information is retrieved.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeLoggingOptionsInput {}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeDatastoreInput {
/// <p>The name of the data store</p>
#[doc(hidden)]
pub datastore_name: std::option::Option<std::string::String>,
/// <p>If true, additional statistical information about the data store is included in the response. This feature can't be used with a data store whose S3 storage is customer-managed.</p>
#[doc(hidden)]
pub include_statistics: bool,
}
impl DescribeDatastoreInput {
/// <p>The name of the data store</p>
pub fn datastore_name(&self) -> std::option::Option<&str> {
self.datastore_name.as_deref()
}
/// <p>If true, additional statistical information about the data store is included in the response. This feature can't be used with a data store whose S3 storage is customer-managed.</p>
pub fn include_statistics(&self) -> bool {
self.include_statistics
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeDatasetInput {
/// <p>The name of the dataset whose information is retrieved.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
}
impl DescribeDatasetInput {
/// <p>The name of the dataset whose information is retrieved.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeChannelInput {
/// <p>The name of the channel whose information is retrieved.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
/// <p>If true, additional statistical information about the channel is included in the response. This feature can't be used with a channel whose S3 storage is customer-managed.</p>
#[doc(hidden)]
pub include_statistics: bool,
}
impl DescribeChannelInput {
/// <p>The name of the channel whose information is retrieved.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
/// <p>If true, additional statistical information about the channel is included in the response. This feature can't be used with a channel whose S3 storage is customer-managed.</p>
pub fn include_statistics(&self) -> bool {
self.include_statistics
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeletePipelineInput {
/// <p>The name of the pipeline to delete.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
}
impl DeletePipelineInput {
/// <p>The name of the pipeline to delete.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDatastoreInput {
/// <p>The name of the data store to delete.</p>
#[doc(hidden)]
pub datastore_name: std::option::Option<std::string::String>,
}
impl DeleteDatastoreInput {
/// <p>The name of the data store to delete.</p>
pub fn datastore_name(&self) -> std::option::Option<&str> {
self.datastore_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDatasetContentInput {
/// <p>The name of the dataset whose content is deleted.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>The version of the dataset whose content is deleted. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl DeleteDatasetContentInput {
/// <p>The name of the dataset whose content is deleted.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>The version of the dataset whose content is deleted. You can also use the strings "$LATEST" or "$LATEST_SUCCEEDED" to delete the latest or latest successfully completed data set. If not specified, "$LATEST_SUCCEEDED" is the default.</p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDatasetInput {
/// <p>The name of the dataset to delete.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
}
impl DeleteDatasetInput {
/// <p>The name of the dataset to delete.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteChannelInput {
/// <p>The name of the channel to delete.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
}
impl DeleteChannelInput {
/// <p>The name of the channel to delete.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreatePipelineInput {
/// <p>The name of the pipeline.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda unctions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
#[doc(hidden)]
pub pipeline_activities: std::option::Option<std::vec::Vec<crate::model::PipelineActivity>>,
/// <p>Metadata which can be used to manage the pipeline.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreatePipelineInput {
/// <p>The name of the pipeline.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
/// <p>A list of <code>PipelineActivity</code> objects. Activities perform transformations on your messages, such as removing, renaming or adding message attributes; filtering messages based on attribute values; invoking your Lambda unctions on messages for advanced processing; or performing mathematical transformations to normalize device data.</p>
/// <p>The list can be 2-25 <code>PipelineActivity</code> objects and must contain both a <code>channel</code> and a <code>datastore</code> activity. Each entry in the list must contain only one activity. For example:</p>
/// <p> <code>pipelineActivities = [ { "channel": { ... } }, { "lambda": { ... } }, ... ]</code> </p>
pub fn pipeline_activities(&self) -> std::option::Option<&[crate::model::PipelineActivity]> {
self.pipeline_activities.as_deref()
}
/// <p>Metadata which can be used to manage the pipeline.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDatastoreInput {
/// <p>The name of the data store.</p>
#[doc(hidden)]
pub datastore_name: std::option::Option<std::string::String>,
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
#[doc(hidden)]
pub datastore_storage: std::option::Option<crate::model::DatastoreStorage>,
/// <p>How long, in days, message data is kept for the data store. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
/// <p>Metadata which can be used to manage the data store.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
#[doc(hidden)]
pub file_format_configuration: std::option::Option<crate::model::FileFormatConfiguration>,
/// <p> Contains information about the partition dimensions in a data store. </p>
#[doc(hidden)]
pub datastore_partitions: std::option::Option<crate::model::DatastorePartitions>,
}
impl CreateDatastoreInput {
/// <p>The name of the data store.</p>
pub fn datastore_name(&self) -> std::option::Option<&str> {
self.datastore_name.as_deref()
}
/// <p>Where data in a data store is stored.. You can choose <code>serviceManagedS3</code> storage, <code>customerManagedS3</code> storage, or <code>iotSiteWiseMultiLayerStorage</code> storage. The default is <code>serviceManagedS3</code>. You can't change the choice of Amazon S3 storage after your data store is created. </p>
pub fn datastore_storage(&self) -> std::option::Option<&crate::model::DatastoreStorage> {
self.datastore_storage.as_ref()
}
/// <p>How long, in days, message data is kept for the data store. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
/// <p>Metadata which can be used to manage the data store.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
/// <p>Contains the configuration information of file formats. IoT Analytics data stores support JSON and <a href="https://parquet.apache.org/">Parquet</a>.</p>
/// <p>The default file format is JSON. You can specify only one format.</p>
/// <p>You can't change the file format after you create the data store.</p>
pub fn file_format_configuration(
&self,
) -> std::option::Option<&crate::model::FileFormatConfiguration> {
self.file_format_configuration.as_ref()
}
/// <p> Contains information about the partition dimensions in a data store. </p>
pub fn datastore_partitions(&self) -> std::option::Option<&crate::model::DatastorePartitions> {
self.datastore_partitions.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDatasetContentInput {
/// <p>The name of the dataset.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>The version ID of the dataset content. To specify <code>versionId</code> for a dataset content, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
#[doc(hidden)]
pub version_id: std::option::Option<std::string::String>,
}
impl CreateDatasetContentInput {
/// <p>The name of the dataset.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>The version ID of the dataset content. To specify <code>versionId</code> for a dataset content, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn version_id(&self) -> std::option::Option<&str> {
self.version_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDatasetInput {
/// <p>The name of the dataset.</p>
#[doc(hidden)]
pub dataset_name: std::option::Option<std::string::String>,
/// <p>A list of actions that create the dataset contents.</p>
#[doc(hidden)]
pub actions: std::option::Option<std::vec::Vec<crate::model::DatasetAction>>,
/// <p>A list of triggers. A trigger causes dataset contents to be populated at a specified time interval or when another dataset's contents are created. The list of triggers can be empty or contain up to five <code>DataSetTrigger</code> objects.</p>
#[doc(hidden)]
pub triggers: std::option::Option<std::vec::Vec<crate::model::DatasetTrigger>>,
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
#[doc(hidden)]
pub content_delivery_rules:
std::option::Option<std::vec::Vec<crate::model::DatasetContentDeliveryRule>>,
/// <p>Optional. How long, in days, versions of dataset contents are kept for the dataset. If not specified or set to <code>null</code>, versions of dataset contents are retained for at most 90 days. The number of versions of dataset contents retained is determined by the <code>versioningConfiguration</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions"> Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
#[doc(hidden)]
pub versioning_configuration: std::option::Option<crate::model::VersioningConfiguration>,
/// <p>Metadata which can be used to manage the dataset.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
#[doc(hidden)]
pub late_data_rules: std::option::Option<std::vec::Vec<crate::model::LateDataRule>>,
}
impl CreateDatasetInput {
/// <p>The name of the dataset.</p>
pub fn dataset_name(&self) -> std::option::Option<&str> {
self.dataset_name.as_deref()
}
/// <p>A list of actions that create the dataset contents.</p>
pub fn actions(&self) -> std::option::Option<&[crate::model::DatasetAction]> {
self.actions.as_deref()
}
/// <p>A list of triggers. A trigger causes dataset contents to be populated at a specified time interval or when another dataset's contents are created. The list of triggers can be empty or contain up to five <code>DataSetTrigger</code> objects.</p>
pub fn triggers(&self) -> std::option::Option<&[crate::model::DatasetTrigger]> {
self.triggers.as_deref()
}
/// <p>When dataset contents are created, they are delivered to destinations specified here.</p>
pub fn content_delivery_rules(
&self,
) -> std::option::Option<&[crate::model::DatasetContentDeliveryRule]> {
self.content_delivery_rules.as_deref()
}
/// <p>Optional. How long, in days, versions of dataset contents are kept for the dataset. If not specified or set to <code>null</code>, versions of dataset contents are retained for at most 90 days. The number of versions of dataset contents retained is determined by the <code>versioningConfiguration</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions"> Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
/// <p>Optional. How many versions of dataset contents are kept. If not specified or set to null, only the latest version plus the latest succeeded version (if they are different) are kept for the time period specified by the <code>retentionPeriod</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions">Keeping Multiple Versions of IoT Analytics datasets</a> in the <i>IoT Analytics User Guide</i>.</p>
pub fn versioning_configuration(
&self,
) -> std::option::Option<&crate::model::VersioningConfiguration> {
self.versioning_configuration.as_ref()
}
/// <p>Metadata which can be used to manage the dataset.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
/// <p>A list of data rules that send notifications to CloudWatch, when data arrives late. To specify <code>lateDataRules</code>, the dataset must use a <a href="https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html">DeltaTimer</a> filter.</p>
pub fn late_data_rules(&self) -> std::option::Option<&[crate::model::LateDataRule]> {
self.late_data_rules.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateChannelInput {
/// <p>The name of the channel.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
#[doc(hidden)]
pub channel_storage: std::option::Option<crate::model::ChannelStorage>,
/// <p>How long, in days, message data is kept for the channel. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
#[doc(hidden)]
pub retention_period: std::option::Option<crate::model::RetentionPeriod>,
/// <p>Metadata which can be used to manage the channel.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateChannelInput {
/// <p>The name of the channel.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
/// <p>Where channel data is stored. You can choose one of <code>serviceManagedS3</code> or <code>customerManagedS3</code> storage. If not specified, the default is <code>serviceManagedS3</code>. You can't change this storage option after the channel is created.</p>
pub fn channel_storage(&self) -> std::option::Option<&crate::model::ChannelStorage> {
self.channel_storage.as_ref()
}
/// <p>How long, in days, message data is kept for the channel. When <code>customerManagedS3</code> storage is selected, this parameter is ignored.</p>
pub fn retention_period(&self) -> std::option::Option<&crate::model::RetentionPeriod> {
self.retention_period.as_ref()
}
/// <p>Metadata which can be used to manage the channel.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelPipelineReprocessingInput {
/// <p>The name of pipeline for which data reprocessing is canceled.</p>
#[doc(hidden)]
pub pipeline_name: std::option::Option<std::string::String>,
/// <p>The ID of the reprocessing task (returned by <code>StartPipelineReprocessing</code>).</p>
#[doc(hidden)]
pub reprocessing_id: std::option::Option<std::string::String>,
}
impl CancelPipelineReprocessingInput {
/// <p>The name of pipeline for which data reprocessing is canceled.</p>
pub fn pipeline_name(&self) -> std::option::Option<&str> {
self.pipeline_name.as_deref()
}
/// <p>The ID of the reprocessing task (returned by <code>StartPipelineReprocessing</code>).</p>
pub fn reprocessing_id(&self) -> std::option::Option<&str> {
self.reprocessing_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchPutMessageInput {
/// <p>The name of the channel where the messages are sent.</p>
#[doc(hidden)]
pub channel_name: std::option::Option<std::string::String>,
/// <p>The list of messages to be sent. Each message has the format: { "messageId": "string", "payload": "string"}.</p>
/// <p>The field names of message payloads (data) that you send to IoT Analytics:</p>
/// <ul>
/// <li> <p>Must contain only alphanumeric characters and undescores (_). No other special characters are allowed.</p> </li>
/// <li> <p>Must begin with an alphabetic character or single underscore (_).</p> </li>
/// <li> <p>Cannot contain hyphens (-).</p> </li>
/// <li> <p>In regular expression terms: "^[A-Za-z_]([A-Za-z0-9]*|[A-Za-z0-9][A-Za-z0-9_]*)$". </p> </li>
/// <li> <p>Cannot be more than 255 characters.</p> </li>
/// <li> <p>Are case insensitive. (Fields named foo and FOO in the same payload are considered duplicates.)</p> </li>
/// </ul>
/// <p>For example, {"temp_01": 29} or {"_temp_01": 29} are valid, but {"temp-01": 29}, {"01_temp": 29} or {"__temp_01": 29} are invalid in message payloads. </p>
#[doc(hidden)]
pub messages: std::option::Option<std::vec::Vec<crate::model::Message>>,
}
impl BatchPutMessageInput {
/// <p>The name of the channel where the messages are sent.</p>
pub fn channel_name(&self) -> std::option::Option<&str> {
self.channel_name.as_deref()
}
/// <p>The list of messages to be sent. Each message has the format: { "messageId": "string", "payload": "string"}.</p>
/// <p>The field names of message payloads (data) that you send to IoT Analytics:</p>
/// <ul>
/// <li> <p>Must contain only alphanumeric characters and undescores (_). No other special characters are allowed.</p> </li>
/// <li> <p>Must begin with an alphabetic character or single underscore (_).</p> </li>
/// <li> <p>Cannot contain hyphens (-).</p> </li>
/// <li> <p>In regular expression terms: "^[A-Za-z_]([A-Za-z0-9]*|[A-Za-z0-9][A-Za-z0-9_]*)$". </p> </li>
/// <li> <p>Cannot be more than 255 characters.</p> </li>
/// <li> <p>Are case insensitive. (Fields named foo and FOO in the same payload are considered duplicates.)</p> </li>
/// </ul>
/// <p>For example, {"temp_01": 29} or {"_temp_01": 29} are valid, but {"temp-01": 29}, {"01_temp": 29} or {"__temp_01": 29} are invalid in message payloads. </p>
pub fn messages(&self) -> std::option::Option<&[crate::model::Message]> {
self.messages.as_deref()
}
}