// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;
/// See [`AddTagsToStreamInput`](crate::input::AddTagsToStreamInput).
pub mod add_tags_to_stream_input {
/// A builder for [`AddTagsToStreamInput`](crate::input::AddTagsToStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// Adds a key-value pair to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>A set of up to 10 key-value pairs to use to create the tags.</p>
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
/// <p>A set of up to 10 key-value pairs to use to create the tags.</p>
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`AddTagsToStreamInput`](crate::input::AddTagsToStreamInput).
pub fn build(
self,
) -> Result<crate::input::AddTagsToStreamInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::AddTagsToStreamInput {
stream_name: self.stream_name,
tags: self.tags,
stream_arn: self.stream_arn,
})
}
}
}
impl AddTagsToStreamInput {
/// Consumes the builder and constructs an Operation<[`AddTagsToStream`](crate::operation::AddTagsToStream)>
#[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::AddTagsToStream,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::AddTagsToStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::AddTagsToStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.AddTagsToStream",
);
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_add_tags_to_stream(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::AddTagsToStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"AddTagsToStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`AddTagsToStreamInput`](crate::input::AddTagsToStreamInput).
pub fn builder() -> crate::input::add_tags_to_stream_input::Builder {
crate::input::add_tags_to_stream_input::Builder::default()
}
}
/// See [`CreateStreamInput`](crate::input::CreateStreamInput).
pub mod create_stream_input {
/// A builder for [`CreateStreamInput`](crate::input::CreateStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_count: std::option::Option<i32>,
pub(crate) stream_mode_details: std::option::Option<crate::model::StreamModeDetails>,
}
impl Builder {
/// <p>A name to identify the stream. The stream name is scoped to the Amazon Web Services account used by the application that creates the stream. It is also scoped by Amazon Web Services Region. That is, two streams in two different Amazon Web Services accounts can have the same name. Two streams in the same Amazon Web Services account but in two different Regions can also have the same name.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>A name to identify the stream. The stream name is scoped to the Amazon Web Services account used by the application that creates the stream. It is also scoped by Amazon Web Services Region. That is, two streams in two different Amazon Web Services accounts can have the same name. Two streams in the same Amazon Web Services account but in two different Regions can also have the same name.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The number of shards that the stream will use. The throughput of the stream is a function of the number of shards; more shards are required for greater provisioned throughput.</p>
pub fn shard_count(mut self, input: i32) -> Self {
self.shard_count = Some(input);
self
}
/// <p>The number of shards that the stream will use. The throughput of the stream is a function of the number of shards; more shards are required for greater provisioned throughput.</p>
pub fn set_shard_count(mut self, input: std::option::Option<i32>) -> Self {
self.shard_count = input;
self
}
/// <p> Indicates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams.</p>
pub fn stream_mode_details(mut self, input: crate::model::StreamModeDetails) -> Self {
self.stream_mode_details = Some(input);
self
}
/// <p> Indicates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams.</p>
pub fn set_stream_mode_details(
mut self,
input: std::option::Option<crate::model::StreamModeDetails>,
) -> Self {
self.stream_mode_details = input;
self
}
/// Consumes the builder and constructs a [`CreateStreamInput`](crate::input::CreateStreamInput).
pub fn build(
self,
) -> Result<crate::input::CreateStreamInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateStreamInput {
stream_name: self.stream_name,
shard_count: self.shard_count,
stream_mode_details: self.stream_mode_details,
})
}
}
}
impl CreateStreamInput {
/// Consumes the builder and constructs an Operation<[`CreateStream`](crate::operation::CreateStream)>
#[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::CreateStream,
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::CreateStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::CreateStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.CreateStream",
);
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_stream(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::CreateStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateStreamInput`](crate::input::CreateStreamInput).
pub fn builder() -> crate::input::create_stream_input::Builder {
crate::input::create_stream_input::Builder::default()
}
}
/// See [`DecreaseStreamRetentionPeriodInput`](crate::input::DecreaseStreamRetentionPeriodInput).
pub mod decrease_stream_retention_period_input {
/// A builder for [`DecreaseStreamRetentionPeriodInput`](crate::input::DecreaseStreamRetentionPeriodInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) retention_period_hours: std::option::Option<i32>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to modify.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to modify.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The new retention period of the stream, in hours. Must be less than the current retention period.</p>
pub fn retention_period_hours(mut self, input: i32) -> Self {
self.retention_period_hours = Some(input);
self
}
/// <p>The new retention period of the stream, in hours. Must be less than the current retention period.</p>
pub fn set_retention_period_hours(mut self, input: std::option::Option<i32>) -> Self {
self.retention_period_hours = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`DecreaseStreamRetentionPeriodInput`](crate::input::DecreaseStreamRetentionPeriodInput).
pub fn build(
self,
) -> Result<
crate::input::DecreaseStreamRetentionPeriodInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DecreaseStreamRetentionPeriodInput {
stream_name: self.stream_name,
retention_period_hours: self.retention_period_hours,
stream_arn: self.stream_arn,
})
}
}
}
impl DecreaseStreamRetentionPeriodInput {
/// Consumes the builder and constructs an Operation<[`DecreaseStreamRetentionPeriod`](crate::operation::DecreaseStreamRetentionPeriod)>
#[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::DecreaseStreamRetentionPeriod,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::DecreaseStreamRetentionPeriodInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DecreaseStreamRetentionPeriodInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DecreaseStreamRetentionPeriod",
);
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_decrease_stream_retention_period(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DecreaseStreamRetentionPeriod::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DecreaseStreamRetentionPeriod",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DecreaseStreamRetentionPeriodInput`](crate::input::DecreaseStreamRetentionPeriodInput).
pub fn builder() -> crate::input::decrease_stream_retention_period_input::Builder {
crate::input::decrease_stream_retention_period_input::Builder::default()
}
}
/// See [`DeleteStreamInput`](crate::input::DeleteStreamInput).
pub mod delete_stream_input {
/// A builder for [`DeleteStreamInput`](crate::input::DeleteStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) enforce_consumer_deletion: std::option::Option<bool>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to delete.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to delete.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>If this parameter is unset (<code>null</code>) or if you set it to <code>false</code>, and the stream has registered consumers, the call to <code>DeleteStream</code> fails with a <code>ResourceInUseException</code>. </p>
pub fn enforce_consumer_deletion(mut self, input: bool) -> Self {
self.enforce_consumer_deletion = Some(input);
self
}
/// <p>If this parameter is unset (<code>null</code>) or if you set it to <code>false</code>, and the stream has registered consumers, the call to <code>DeleteStream</code> fails with a <code>ResourceInUseException</code>. </p>
pub fn set_enforce_consumer_deletion(mut self, input: std::option::Option<bool>) -> Self {
self.enforce_consumer_deletion = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`DeleteStreamInput`](crate::input::DeleteStreamInput).
pub fn build(
self,
) -> Result<crate::input::DeleteStreamInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteStreamInput {
stream_name: self.stream_name,
enforce_consumer_deletion: self.enforce_consumer_deletion,
stream_arn: self.stream_arn,
})
}
}
}
impl DeleteStreamInput {
/// Consumes the builder and constructs an Operation<[`DeleteStream`](crate::operation::DeleteStream)>
#[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::DeleteStream,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::DeleteStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeleteStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DeleteStream",
);
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_delete_stream(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DeleteStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteStreamInput`](crate::input::DeleteStreamInput).
pub fn builder() -> crate::input::delete_stream_input::Builder {
crate::input::delete_stream_input::Builder::default()
}
}
/// See [`DeregisterStreamConsumerInput`](crate::input::DeregisterStreamConsumerInput).
pub mod deregister_stream_consumer_input {
/// A builder for [`DeregisterStreamConsumerInput`](crate::input::DeregisterStreamConsumerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_arn: std::option::Option<std::string::String>,
pub(crate) consumer_name: std::option::Option<std::string::String>,
pub(crate) consumer_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// <p>The name that you gave to the consumer.</p>
pub fn consumer_name(mut self, input: impl Into<std::string::String>) -> Self {
self.consumer_name = Some(input.into());
self
}
/// <p>The name that you gave to the consumer.</p>
pub fn set_consumer_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.consumer_name = input;
self
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer. If you don't know the ARN of the consumer that you want to deregister, you can use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are currently registered with a given data stream. The description of a consumer contains its ARN.</p>
pub fn consumer_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.consumer_arn = Some(input.into());
self
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer. If you don't know the ARN of the consumer that you want to deregister, you can use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are currently registered with a given data stream. The description of a consumer contains its ARN.</p>
pub fn set_consumer_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.consumer_arn = input;
self
}
/// Consumes the builder and constructs a [`DeregisterStreamConsumerInput`](crate::input::DeregisterStreamConsumerInput).
pub fn build(
self,
) -> Result<
crate::input::DeregisterStreamConsumerInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeregisterStreamConsumerInput {
stream_arn: self.stream_arn,
consumer_name: self.consumer_name,
consumer_arn: self.consumer_arn,
})
}
}
}
impl DeregisterStreamConsumerInput {
/// Consumes the builder and constructs an Operation<[`DeregisterStreamConsumer`](crate::operation::DeregisterStreamConsumer)>
#[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::DeregisterStreamConsumer,
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())
.set_operation_type(Some("control".to_string()))
.set_consumer_arn(self.consumer_arn.clone())
.set_stream_arn(self.stream_arn.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::DeregisterStreamConsumerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DeregisterStreamConsumerInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DeregisterStreamConsumer",
);
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_deregister_stream_consumer(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DeregisterStreamConsumer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeregisterStreamConsumer",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeregisterStreamConsumerInput`](crate::input::DeregisterStreamConsumerInput).
pub fn builder() -> crate::input::deregister_stream_consumer_input::Builder {
crate::input::deregister_stream_consumer_input::Builder::default()
}
}
/// See [`DescribeLimitsInput`](crate::input::DescribeLimitsInput).
pub mod describe_limits_input {
/// A builder for [`DescribeLimitsInput`](crate::input::DescribeLimitsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
/// Consumes the builder and constructs a [`DescribeLimitsInput`](crate::input::DescribeLimitsInput).
pub fn build(
self,
) -> Result<crate::input::DescribeLimitsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeLimitsInput {})
}
}
}
impl DescribeLimitsInput {
/// Consumes the builder and constructs an Operation<[`DescribeLimits`](crate::operation::DescribeLimits)>
#[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::DescribeLimits,
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::DescribeLimitsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeLimitsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DescribeLimits",
);
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_describe_limits(&self)?,
);
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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DescribeLimits::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeLimits",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeLimitsInput`](crate::input::DescribeLimitsInput).
pub fn builder() -> crate::input::describe_limits_input::Builder {
crate::input::describe_limits_input::Builder::default()
}
}
/// See [`DescribeStreamInput`](crate::input::DescribeStreamInput).
pub mod describe_stream_input {
/// A builder for [`DescribeStreamInput`](crate::input::DescribeStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) limit: std::option::Option<i32>,
pub(crate) exclusive_start_shard_id: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to describe.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to describe.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The maximum number of shards to return in a single call. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn limit(mut self, input: i32) -> Self {
self.limit = Some(input);
self
}
/// <p>The maximum number of shards to return in a single call. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
self.limit = input;
self
}
/// <p>The shard ID of the shard to start with.</p>
/// <p>Specify this parameter to indicate that you want to describe the stream starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior for <code>DescribeStream</code> is to describe the stream starting with the first shard in the stream.</p>
pub fn exclusive_start_shard_id(mut self, input: impl Into<std::string::String>) -> Self {
self.exclusive_start_shard_id = Some(input.into());
self
}
/// <p>The shard ID of the shard to start with.</p>
/// <p>Specify this parameter to indicate that you want to describe the stream starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior for <code>DescribeStream</code> is to describe the stream starting with the first shard in the stream.</p>
pub fn set_exclusive_start_shard_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.exclusive_start_shard_id = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`DescribeStreamInput`](crate::input::DescribeStreamInput).
pub fn build(
self,
) -> Result<crate::input::DescribeStreamInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeStreamInput {
stream_name: self.stream_name,
limit: self.limit,
exclusive_start_shard_id: self.exclusive_start_shard_id,
stream_arn: self.stream_arn,
})
}
}
}
impl DescribeStreamInput {
/// Consumes the builder and constructs an Operation<[`DescribeStream`](crate::operation::DescribeStream)>
#[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::DescribeStream,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::DescribeStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DescribeStream",
);
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_describe_stream(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DescribeStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeStreamInput`](crate::input::DescribeStreamInput).
pub fn builder() -> crate::input::describe_stream_input::Builder {
crate::input::describe_stream_input::Builder::default()
}
}
/// See [`DescribeStreamConsumerInput`](crate::input::DescribeStreamConsumerInput).
pub mod describe_stream_consumer_input {
/// A builder for [`DescribeStreamConsumerInput`](crate::input::DescribeStreamConsumerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_arn: std::option::Option<std::string::String>,
pub(crate) consumer_name: std::option::Option<std::string::String>,
pub(crate) consumer_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// <p>The name that you gave to the consumer.</p>
pub fn consumer_name(mut self, input: impl Into<std::string::String>) -> Self {
self.consumer_name = Some(input.into());
self
}
/// <p>The name that you gave to the consumer.</p>
pub fn set_consumer_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.consumer_name = input;
self
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer.</p>
pub fn consumer_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.consumer_arn = Some(input.into());
self
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer.</p>
pub fn set_consumer_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.consumer_arn = input;
self
}
/// Consumes the builder and constructs a [`DescribeStreamConsumerInput`](crate::input::DescribeStreamConsumerInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeStreamConsumerInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeStreamConsumerInput {
stream_arn: self.stream_arn,
consumer_name: self.consumer_name,
consumer_arn: self.consumer_arn,
})
}
}
}
impl DescribeStreamConsumerInput {
/// Consumes the builder and constructs an Operation<[`DescribeStreamConsumer`](crate::operation::DescribeStreamConsumer)>
#[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::DescribeStreamConsumer,
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())
.set_operation_type(Some("control".to_string()))
.set_consumer_arn(self.consumer_arn.clone())
.set_stream_arn(self.stream_arn.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::DescribeStreamConsumerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeStreamConsumerInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DescribeStreamConsumer",
);
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_describe_stream_consumer(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DescribeStreamConsumer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeStreamConsumer",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeStreamConsumerInput`](crate::input::DescribeStreamConsumerInput).
pub fn builder() -> crate::input::describe_stream_consumer_input::Builder {
crate::input::describe_stream_consumer_input::Builder::default()
}
}
/// See [`DescribeStreamSummaryInput`](crate::input::DescribeStreamSummaryInput).
pub mod describe_stream_summary_input {
/// A builder for [`DescribeStreamSummaryInput`](crate::input::DescribeStreamSummaryInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to describe.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to describe.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`DescribeStreamSummaryInput`](crate::input::DescribeStreamSummaryInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeStreamSummaryInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeStreamSummaryInput {
stream_name: self.stream_name,
stream_arn: self.stream_arn,
})
}
}
}
impl DescribeStreamSummaryInput {
/// Consumes the builder and constructs an Operation<[`DescribeStreamSummary`](crate::operation::DescribeStreamSummary)>
#[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::DescribeStreamSummary,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::DescribeStreamSummaryInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DescribeStreamSummaryInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DescribeStreamSummary",
);
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_describe_stream_summary(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DescribeStreamSummary::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeStreamSummary",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeStreamSummaryInput`](crate::input::DescribeStreamSummaryInput).
pub fn builder() -> crate::input::describe_stream_summary_input::Builder {
crate::input::describe_stream_summary_input::Builder::default()
}
}
/// See [`DisableEnhancedMonitoringInput`](crate::input::DisableEnhancedMonitoringInput).
pub mod disable_enhanced_monitoring_input {
/// A builder for [`DisableEnhancedMonitoringInput`](crate::input::DisableEnhancedMonitoringInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_level_metrics:
std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the Kinesis data stream for which to disable enhanced monitoring.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the Kinesis data stream for which to disable enhanced monitoring.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// Appends an item to `shard_level_metrics`.
///
/// To override the contents of this collection use [`set_shard_level_metrics`](Self::set_shard_level_metrics).
///
/// <p>List of shard-level metrics to disable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" disables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn shard_level_metrics(mut self, input: crate::model::MetricsName) -> Self {
let mut v = self.shard_level_metrics.unwrap_or_default();
v.push(input);
self.shard_level_metrics = Some(v);
self
}
/// <p>List of shard-level metrics to disable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" disables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn set_shard_level_metrics(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
) -> Self {
self.shard_level_metrics = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`DisableEnhancedMonitoringInput`](crate::input::DisableEnhancedMonitoringInput).
pub fn build(
self,
) -> Result<
crate::input::DisableEnhancedMonitoringInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DisableEnhancedMonitoringInput {
stream_name: self.stream_name,
shard_level_metrics: self.shard_level_metrics,
stream_arn: self.stream_arn,
})
}
}
}
impl DisableEnhancedMonitoringInput {
/// Consumes the builder and constructs an Operation<[`DisableEnhancedMonitoring`](crate::operation::DisableEnhancedMonitoring)>
#[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::DisableEnhancedMonitoring,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::DisableEnhancedMonitoringInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::DisableEnhancedMonitoringInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.DisableEnhancedMonitoring",
);
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_disable_enhanced_monitoring(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::DisableEnhancedMonitoring::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DisableEnhancedMonitoring",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DisableEnhancedMonitoringInput`](crate::input::DisableEnhancedMonitoringInput).
pub fn builder() -> crate::input::disable_enhanced_monitoring_input::Builder {
crate::input::disable_enhanced_monitoring_input::Builder::default()
}
}
/// See [`EnableEnhancedMonitoringInput`](crate::input::EnableEnhancedMonitoringInput).
pub mod enable_enhanced_monitoring_input {
/// A builder for [`EnableEnhancedMonitoringInput`](crate::input::EnableEnhancedMonitoringInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_level_metrics:
std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream for which to enable enhanced monitoring.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream for which to enable enhanced monitoring.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// Appends an item to `shard_level_metrics`.
///
/// To override the contents of this collection use [`set_shard_level_metrics`](Self::set_shard_level_metrics).
///
/// <p>List of shard-level metrics to enable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" enables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn shard_level_metrics(mut self, input: crate::model::MetricsName) -> Self {
let mut v = self.shard_level_metrics.unwrap_or_default();
v.push(input);
self.shard_level_metrics = Some(v);
self
}
/// <p>List of shard-level metrics to enable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" enables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn set_shard_level_metrics(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
) -> Self {
self.shard_level_metrics = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`EnableEnhancedMonitoringInput`](crate::input::EnableEnhancedMonitoringInput).
pub fn build(
self,
) -> Result<
crate::input::EnableEnhancedMonitoringInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::EnableEnhancedMonitoringInput {
stream_name: self.stream_name,
shard_level_metrics: self.shard_level_metrics,
stream_arn: self.stream_arn,
})
}
}
}
impl EnableEnhancedMonitoringInput {
/// Consumes the builder and constructs an Operation<[`EnableEnhancedMonitoring`](crate::operation::EnableEnhancedMonitoring)>
#[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::EnableEnhancedMonitoring,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::EnableEnhancedMonitoringInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::EnableEnhancedMonitoringInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.EnableEnhancedMonitoring",
);
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_enable_enhanced_monitoring(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::EnableEnhancedMonitoring::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"EnableEnhancedMonitoring",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`EnableEnhancedMonitoringInput`](crate::input::EnableEnhancedMonitoringInput).
pub fn builder() -> crate::input::enable_enhanced_monitoring_input::Builder {
crate::input::enable_enhanced_monitoring_input::Builder::default()
}
}
/// See [`GetRecordsInput`](crate::input::GetRecordsInput).
pub mod get_records_input {
/// A builder for [`GetRecordsInput`](crate::input::GetRecordsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) shard_iterator: std::option::Option<std::string::String>,
pub(crate) limit: std::option::Option<i32>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The position in the shard from which you want to start sequentially reading data records. A shard iterator specifies this position using the sequence number of a data record in the shard.</p>
pub fn shard_iterator(mut self, input: impl Into<std::string::String>) -> Self {
self.shard_iterator = Some(input.into());
self
}
/// <p>The position in the shard from which you want to start sequentially reading data records. A shard iterator specifies this position using the sequence number of a data record in the shard.</p>
pub fn set_shard_iterator(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.shard_iterator = input;
self
}
/// <p>The maximum number of records to return. Specify a value of up to 10,000. If you specify a value that is greater than 10,000, <code>GetRecords</code> throws <code>InvalidArgumentException</code>. The default value is 10,000.</p>
pub fn limit(mut self, input: i32) -> Self {
self.limit = Some(input);
self
}
/// <p>The maximum number of records to return. Specify a value of up to 10,000. If you specify a value that is greater than 10,000, <code>GetRecords</code> throws <code>InvalidArgumentException</code>. The default value is 10,000.</p>
pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
self.limit = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`GetRecordsInput`](crate::input::GetRecordsInput).
pub fn build(
self,
) -> Result<crate::input::GetRecordsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::GetRecordsInput {
shard_iterator: self.shard_iterator,
limit: self.limit,
stream_arn: self.stream_arn,
})
}
}
}
impl GetRecordsInput {
/// Consumes the builder and constructs an Operation<[`GetRecords`](crate::operation::GetRecords)>
#[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::GetRecords,
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())
.set_operation_type(Some("data".to_string()))
.set_stream_arn(self.stream_arn.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::GetRecordsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetRecordsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.GetRecords",
);
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_get_records(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::GetRecords::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetRecords",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetRecordsInput`](crate::input::GetRecordsInput).
pub fn builder() -> crate::input::get_records_input::Builder {
crate::input::get_records_input::Builder::default()
}
}
/// See [`GetShardIteratorInput`](crate::input::GetShardIteratorInput).
pub mod get_shard_iterator_input {
/// A builder for [`GetShardIteratorInput`](crate::input::GetShardIteratorInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_id: std::option::Option<std::string::String>,
pub(crate) shard_iterator_type: std::option::Option<crate::model::ShardIteratorType>,
pub(crate) starting_sequence_number: std::option::Option<std::string::String>,
pub(crate) timestamp: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the Amazon Kinesis data stream.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the Amazon Kinesis data stream.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The shard ID of the Kinesis Data Streams shard to get the iterator for.</p>
pub fn shard_id(mut self, input: impl Into<std::string::String>) -> Self {
self.shard_id = Some(input.into());
self
}
/// <p>The shard ID of the Kinesis Data Streams shard to get the iterator for.</p>
pub fn set_shard_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.shard_id = input;
self
}
/// <p>Determines how the shard iterator is used to start reading data records from the shard.</p>
/// <p>The following are the valid Amazon Kinesis shard iterator types:</p>
/// <ul>
/// <li> <p>AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AT_TIMESTAMP - Start reading from the position denoted by a specific time stamp, provided in the value <code>Timestamp</code>.</p> </li>
/// <li> <p>TRIM_HORIZON - Start reading at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.</p> </li>
/// <li> <p>LATEST - Start reading just after the most recent record in the shard, so that you always read the most recent data in the shard.</p> </li>
/// </ul>
pub fn shard_iterator_type(mut self, input: crate::model::ShardIteratorType) -> Self {
self.shard_iterator_type = Some(input);
self
}
/// <p>Determines how the shard iterator is used to start reading data records from the shard.</p>
/// <p>The following are the valid Amazon Kinesis shard iterator types:</p>
/// <ul>
/// <li> <p>AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AT_TIMESTAMP - Start reading from the position denoted by a specific time stamp, provided in the value <code>Timestamp</code>.</p> </li>
/// <li> <p>TRIM_HORIZON - Start reading at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.</p> </li>
/// <li> <p>LATEST - Start reading just after the most recent record in the shard, so that you always read the most recent data in the shard.</p> </li>
/// </ul>
pub fn set_shard_iterator_type(
mut self,
input: std::option::Option<crate::model::ShardIteratorType>,
) -> Self {
self.shard_iterator_type = input;
self
}
/// <p>The sequence number of the data record in the shard from which to start reading. Used with shard iterator type AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER.</p>
pub fn starting_sequence_number(mut self, input: impl Into<std::string::String>) -> Self {
self.starting_sequence_number = Some(input.into());
self
}
/// <p>The sequence number of the data record in the shard from which to start reading. Used with shard iterator type AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER.</p>
pub fn set_starting_sequence_number(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.starting_sequence_number = input;
self
}
/// <p>The time stamp of the data record from which to start reading. Used with shard iterator type AT_TIMESTAMP. A time stamp is the Unix epoch date with precision in milliseconds. For example, <code>2016-04-04T19:58:46.480-00:00</code> or <code>1459799926.480</code>. If a record with this exact time stamp does not exist, the iterator returned is for the next (later) record. If the time stamp is older than the current trim horizon, the iterator returned is for the oldest untrimmed data record (TRIM_HORIZON).</p>
pub fn timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.timestamp = Some(input);
self
}
/// <p>The time stamp of the data record from which to start reading. Used with shard iterator type AT_TIMESTAMP. A time stamp is the Unix epoch date with precision in milliseconds. For example, <code>2016-04-04T19:58:46.480-00:00</code> or <code>1459799926.480</code>. If a record with this exact time stamp does not exist, the iterator returned is for the next (later) record. If the time stamp is older than the current trim horizon, the iterator returned is for the oldest untrimmed data record (TRIM_HORIZON).</p>
pub fn set_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.timestamp = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`GetShardIteratorInput`](crate::input::GetShardIteratorInput).
pub fn build(
self,
) -> Result<
crate::input::GetShardIteratorInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::GetShardIteratorInput {
stream_name: self.stream_name,
shard_id: self.shard_id,
shard_iterator_type: self.shard_iterator_type,
starting_sequence_number: self.starting_sequence_number,
timestamp: self.timestamp,
stream_arn: self.stream_arn,
})
}
}
}
impl GetShardIteratorInput {
/// Consumes the builder and constructs an Operation<[`GetShardIterator`](crate::operation::GetShardIterator)>
#[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::GetShardIterator,
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())
.set_operation_type(Some("data".to_string()))
.set_stream_arn(self.stream_arn.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::GetShardIteratorInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::GetShardIteratorInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.GetShardIterator",
);
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_get_shard_iterator(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::GetShardIterator::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"GetShardIterator",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`GetShardIteratorInput`](crate::input::GetShardIteratorInput).
pub fn builder() -> crate::input::get_shard_iterator_input::Builder {
crate::input::get_shard_iterator_input::Builder::default()
}
}
/// See [`IncreaseStreamRetentionPeriodInput`](crate::input::IncreaseStreamRetentionPeriodInput).
pub mod increase_stream_retention_period_input {
/// A builder for [`IncreaseStreamRetentionPeriodInput`](crate::input::IncreaseStreamRetentionPeriodInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) retention_period_hours: std::option::Option<i32>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to modify.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to modify.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The new retention period of the stream, in hours. Must be more than the current retention period.</p>
pub fn retention_period_hours(mut self, input: i32) -> Self {
self.retention_period_hours = Some(input);
self
}
/// <p>The new retention period of the stream, in hours. Must be more than the current retention period.</p>
pub fn set_retention_period_hours(mut self, input: std::option::Option<i32>) -> Self {
self.retention_period_hours = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`IncreaseStreamRetentionPeriodInput`](crate::input::IncreaseStreamRetentionPeriodInput).
pub fn build(
self,
) -> Result<
crate::input::IncreaseStreamRetentionPeriodInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::IncreaseStreamRetentionPeriodInput {
stream_name: self.stream_name,
retention_period_hours: self.retention_period_hours,
stream_arn: self.stream_arn,
})
}
}
}
impl IncreaseStreamRetentionPeriodInput {
/// Consumes the builder and constructs an Operation<[`IncreaseStreamRetentionPeriod`](crate::operation::IncreaseStreamRetentionPeriod)>
#[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::IncreaseStreamRetentionPeriod,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::IncreaseStreamRetentionPeriodInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::IncreaseStreamRetentionPeriodInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.IncreaseStreamRetentionPeriod",
);
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_increase_stream_retention_period(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::IncreaseStreamRetentionPeriod::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"IncreaseStreamRetentionPeriod",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`IncreaseStreamRetentionPeriodInput`](crate::input::IncreaseStreamRetentionPeriodInput).
pub fn builder() -> crate::input::increase_stream_retention_period_input::Builder {
crate::input::increase_stream_retention_period_input::Builder::default()
}
}
/// See [`ListShardsInput`](crate::input::ListShardsInput).
pub mod list_shards_input {
/// A builder for [`ListShardsInput`](crate::input::ListShardsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) exclusive_start_shard_id: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) stream_creation_timestamp: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) shard_filter: std::option::Option<crate::model::ShardFilter>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the data stream whose shards you want to list. </p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the data stream whose shards you want to list. </p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>When the number of shards in the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of shards in the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of shards that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListShards</code> operation.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListShards</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListShards</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When the number of shards in the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of shards in the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of shards that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListShards</code> operation.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListShards</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListShards</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>Specify this parameter to indicate that you want to list the shards starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior is for <code>ListShards</code> to list the shards starting with the first one in the stream.</p>
/// <p>You cannot specify this parameter if you specify <code>NextToken</code>.</p>
pub fn exclusive_start_shard_id(mut self, input: impl Into<std::string::String>) -> Self {
self.exclusive_start_shard_id = Some(input.into());
self
}
/// <p>Specify this parameter to indicate that you want to list the shards starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior is for <code>ListShards</code> to list the shards starting with the first one in the stream.</p>
/// <p>You cannot specify this parameter if you specify <code>NextToken</code>.</p>
pub fn set_exclusive_start_shard_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.exclusive_start_shard_id = input;
self
}
/// <p>The maximum number of shards to return in a single call to <code>ListShards</code>. The maximum number of shards to return in a single call. The default value is 1000. If you specify a value greater than 1000, at most 1000 results are returned. </p>
/// <p>When the number of shards to be listed is greater than the value of <code>MaxResults</code>, the response contains a <code>NextToken</code> value that you can use in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of shards to return in a single call to <code>ListShards</code>. The maximum number of shards to return in a single call. The default value is 1000. If you specify a value greater than 1000, at most 1000 results are returned. </p>
/// <p>When the number of shards to be listed is greater than the value of <code>MaxResults</code>, the response contains a <code>NextToken</code> value that you can use in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the shards for.</p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn stream_creation_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.stream_creation_timestamp = Some(input);
self
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the shards for.</p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn set_stream_creation_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.stream_creation_timestamp = input;
self
}
/// <p>Enables you to filter out the response of the <code>ListShards</code> API. You can only specify one filter at a time. </p>
/// <p>If you use the <code>ShardFilter</code> parameter when invoking the ListShards API, the <code>Type</code> is the required property and must be specified. If you specify the <code>AT_TRIM_HORIZON</code>, <code>FROM_TRIM_HORIZON</code>, or <code>AT_LATEST</code> types, you do not need to specify either the <code>ShardId</code> or the <code>Timestamp</code> optional properties. </p>
/// <p>If you specify the <code>AFTER_SHARD_ID</code> type, you must also provide the value for the optional <code>ShardId</code> property. The <code>ShardId</code> property is identical in fuctionality to the <code>ExclusiveStartShardId</code> parameter of the <code>ListShards</code> API. When <code>ShardId</code> property is specified, the response includes the shards starting with the shard whose ID immediately follows the <code>ShardId</code> that you provided. </p>
/// <p>If you specify the <code>AT_TIMESTAMP</code> or <code>FROM_TIMESTAMP_ID</code> type, you must also provide the value for the optional <code>Timestamp</code> property. If you specify the AT_TIMESTAMP type, then all shards that were open at the provided timestamp are returned. If you specify the FROM_TIMESTAMP type, then all shards starting from the provided timestamp to TIP are returned. </p>
pub fn shard_filter(mut self, input: crate::model::ShardFilter) -> Self {
self.shard_filter = Some(input);
self
}
/// <p>Enables you to filter out the response of the <code>ListShards</code> API. You can only specify one filter at a time. </p>
/// <p>If you use the <code>ShardFilter</code> parameter when invoking the ListShards API, the <code>Type</code> is the required property and must be specified. If you specify the <code>AT_TRIM_HORIZON</code>, <code>FROM_TRIM_HORIZON</code>, or <code>AT_LATEST</code> types, you do not need to specify either the <code>ShardId</code> or the <code>Timestamp</code> optional properties. </p>
/// <p>If you specify the <code>AFTER_SHARD_ID</code> type, you must also provide the value for the optional <code>ShardId</code> property. The <code>ShardId</code> property is identical in fuctionality to the <code>ExclusiveStartShardId</code> parameter of the <code>ListShards</code> API. When <code>ShardId</code> property is specified, the response includes the shards starting with the shard whose ID immediately follows the <code>ShardId</code> that you provided. </p>
/// <p>If you specify the <code>AT_TIMESTAMP</code> or <code>FROM_TIMESTAMP_ID</code> type, you must also provide the value for the optional <code>Timestamp</code> property. If you specify the AT_TIMESTAMP type, then all shards that were open at the provided timestamp are returned. If you specify the FROM_TIMESTAMP type, then all shards starting from the provided timestamp to TIP are returned. </p>
pub fn set_shard_filter(
mut self,
input: std::option::Option<crate::model::ShardFilter>,
) -> Self {
self.shard_filter = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`ListShardsInput`](crate::input::ListShardsInput).
pub fn build(
self,
) -> Result<crate::input::ListShardsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListShardsInput {
stream_name: self.stream_name,
next_token: self.next_token,
exclusive_start_shard_id: self.exclusive_start_shard_id,
max_results: self.max_results,
stream_creation_timestamp: self.stream_creation_timestamp,
shard_filter: self.shard_filter,
stream_arn: self.stream_arn,
})
}
}
}
impl ListShardsInput {
/// Consumes the builder and constructs an Operation<[`ListShards`](crate::operation::ListShards)>
#[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::ListShards,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::ListShardsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListShardsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.ListShards",
);
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_list_shards(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::ListShards::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListShards",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListShardsInput`](crate::input::ListShardsInput).
pub fn builder() -> crate::input::list_shards_input::Builder {
crate::input::list_shards_input::Builder::default()
}
}
/// See [`ListStreamConsumersInput`](crate::input::ListStreamConsumersInput).
pub mod list_stream_consumers_input {
/// A builder for [`ListStreamConsumersInput`](crate::input::ListStreamConsumersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_arn: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) stream_creation_timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl Builder {
/// <p>The ARN of the Kinesis data stream for which you want to list the registered consumers. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the Kinesis data stream for which you want to list the registered consumers. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// <p>When the number of consumers that are registered with the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of consumers that are registered with the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListStreamConsumers</code> to list the next set of registered consumers.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of consumers that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListStreamConsumers</code> operation to list the next set of consumers.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListStreamConsumers</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListStreamConsumers</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When the number of consumers that are registered with the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of consumers that are registered with the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListStreamConsumers</code> to list the next set of registered consumers.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of consumers that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListStreamConsumers</code> operation to list the next set of consumers.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListStreamConsumers</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListStreamConsumers</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
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 consumers that you want a single call of <code>ListStreamConsumers</code> to return. The default value is 100. If you specify a value greater than 100, at most 100 results are returned. </p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of consumers that you want a single call of <code>ListStreamConsumers</code> to return. The default value is 100. If you specify a value greater than 100, at most 100 results are returned. </p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the consumers for. </p>
/// <p>You can't specify this parameter if you specify the NextToken parameter. </p>
pub fn stream_creation_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.stream_creation_timestamp = Some(input);
self
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the consumers for. </p>
/// <p>You can't specify this parameter if you specify the NextToken parameter. </p>
pub fn set_stream_creation_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.stream_creation_timestamp = input;
self
}
/// Consumes the builder and constructs a [`ListStreamConsumersInput`](crate::input::ListStreamConsumersInput).
pub fn build(
self,
) -> Result<
crate::input::ListStreamConsumersInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListStreamConsumersInput {
stream_arn: self.stream_arn,
next_token: self.next_token,
max_results: self.max_results,
stream_creation_timestamp: self.stream_creation_timestamp,
})
}
}
}
impl ListStreamConsumersInput {
/// Consumes the builder and constructs an Operation<[`ListStreamConsumers`](crate::operation::ListStreamConsumers)>
#[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::ListStreamConsumers,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::ListStreamConsumersInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListStreamConsumersInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.ListStreamConsumers",
);
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_list_stream_consumers(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::ListStreamConsumers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListStreamConsumers",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListStreamConsumersInput`](crate::input::ListStreamConsumersInput).
pub fn builder() -> crate::input::list_stream_consumers_input::Builder {
crate::input::list_stream_consumers_input::Builder::default()
}
}
/// See [`ListStreamsInput`](crate::input::ListStreamsInput).
pub mod list_streams_input {
/// A builder for [`ListStreamsInput`](crate::input::ListStreamsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) limit: std::option::Option<i32>,
pub(crate) exclusive_start_stream_name: std::option::Option<std::string::String>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of streams to list. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn limit(mut self, input: i32) -> Self {
self.limit = Some(input);
self
}
/// <p>The maximum number of streams to list. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
self.limit = input;
self
}
/// <p>The name of the stream to start the list with.</p>
pub fn exclusive_start_stream_name(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.exclusive_start_stream_name = Some(input.into());
self
}
/// <p>The name of the stream to start the list with.</p>
pub fn set_exclusive_start_stream_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.exclusive_start_stream_name = input;
self
}
/// <p></p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p></p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// Consumes the builder and constructs a [`ListStreamsInput`](crate::input::ListStreamsInput).
pub fn build(
self,
) -> Result<crate::input::ListStreamsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListStreamsInput {
limit: self.limit,
exclusive_start_stream_name: self.exclusive_start_stream_name,
next_token: self.next_token,
})
}
}
}
impl ListStreamsInput {
/// Consumes the builder and constructs an Operation<[`ListStreams`](crate::operation::ListStreams)>
#[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::ListStreams,
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::ListStreamsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListStreamsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.ListStreams",
);
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_list_streams(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::ListStreams::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListStreams",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListStreamsInput`](crate::input::ListStreamsInput).
pub fn builder() -> crate::input::list_streams_input::Builder {
crate::input::list_streams_input::Builder::default()
}
}
/// See [`ListTagsForStreamInput`](crate::input::ListTagsForStreamInput).
pub mod list_tags_for_stream_input {
/// A builder for [`ListTagsForStreamInput`](crate::input::ListTagsForStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) exclusive_start_tag_key: std::option::Option<std::string::String>,
pub(crate) limit: std::option::Option<i32>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The key to use as the starting point for the list of tags. If this parameter is set, <code>ListTagsForStream</code> gets all tags that occur after <code>ExclusiveStartTagKey</code>. </p>
pub fn exclusive_start_tag_key(mut self, input: impl Into<std::string::String>) -> Self {
self.exclusive_start_tag_key = Some(input.into());
self
}
/// <p>The key to use as the starting point for the list of tags. If this parameter is set, <code>ListTagsForStream</code> gets all tags that occur after <code>ExclusiveStartTagKey</code>. </p>
pub fn set_exclusive_start_tag_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.exclusive_start_tag_key = input;
self
}
/// <p>The number of tags to return. If this number is less than the total number of tags associated with the stream, <code>HasMoreTags</code> is set to <code>true</code>. To list additional tags, set <code>ExclusiveStartTagKey</code> to the last key in the response.</p>
pub fn limit(mut self, input: i32) -> Self {
self.limit = Some(input);
self
}
/// <p>The number of tags to return. If this number is less than the total number of tags associated with the stream, <code>HasMoreTags</code> is set to <code>true</code>. To list additional tags, set <code>ExclusiveStartTagKey</code> to the last key in the response.</p>
pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
self.limit = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`ListTagsForStreamInput`](crate::input::ListTagsForStreamInput).
pub fn build(
self,
) -> Result<
crate::input::ListTagsForStreamInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListTagsForStreamInput {
stream_name: self.stream_name,
exclusive_start_tag_key: self.exclusive_start_tag_key,
limit: self.limit,
stream_arn: self.stream_arn,
})
}
}
}
impl ListTagsForStreamInput {
/// Consumes the builder and constructs an Operation<[`ListTagsForStream`](crate::operation::ListTagsForStream)>
#[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::ListTagsForStream,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::ListTagsForStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListTagsForStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.ListTagsForStream",
);
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_list_tags_for_stream(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::ListTagsForStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListTagsForStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListTagsForStreamInput`](crate::input::ListTagsForStreamInput).
pub fn builder() -> crate::input::list_tags_for_stream_input::Builder {
crate::input::list_tags_for_stream_input::Builder::default()
}
}
/// See [`MergeShardsInput`](crate::input::MergeShardsInput).
pub mod merge_shards_input {
/// A builder for [`MergeShardsInput`](crate::input::MergeShardsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_to_merge: std::option::Option<std::string::String>,
pub(crate) adjacent_shard_to_merge: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream for the merge.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream for the merge.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The shard ID of the shard to combine with the adjacent shard for the merge.</p>
pub fn shard_to_merge(mut self, input: impl Into<std::string::String>) -> Self {
self.shard_to_merge = Some(input.into());
self
}
/// <p>The shard ID of the shard to combine with the adjacent shard for the merge.</p>
pub fn set_shard_to_merge(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.shard_to_merge = input;
self
}
/// <p>The shard ID of the adjacent shard for the merge.</p>
pub fn adjacent_shard_to_merge(mut self, input: impl Into<std::string::String>) -> Self {
self.adjacent_shard_to_merge = Some(input.into());
self
}
/// <p>The shard ID of the adjacent shard for the merge.</p>
pub fn set_adjacent_shard_to_merge(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.adjacent_shard_to_merge = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`MergeShardsInput`](crate::input::MergeShardsInput).
pub fn build(
self,
) -> Result<crate::input::MergeShardsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::MergeShardsInput {
stream_name: self.stream_name,
shard_to_merge: self.shard_to_merge,
adjacent_shard_to_merge: self.adjacent_shard_to_merge,
stream_arn: self.stream_arn,
})
}
}
}
impl MergeShardsInput {
/// Consumes the builder and constructs an Operation<[`MergeShards`](crate::operation::MergeShards)>
#[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::MergeShards,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::MergeShardsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::MergeShardsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.MergeShards",
);
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_merge_shards(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::MergeShards::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"MergeShards",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`MergeShardsInput`](crate::input::MergeShardsInput).
pub fn builder() -> crate::input::merge_shards_input::Builder {
crate::input::merge_shards_input::Builder::default()
}
}
/// See [`PutRecordInput`](crate::input::PutRecordInput).
pub mod put_record_input {
/// A builder for [`PutRecordInput`](crate::input::PutRecordInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) data: std::option::Option<aws_smithy_types::Blob>,
pub(crate) partition_key: std::option::Option<std::string::String>,
pub(crate) explicit_hash_key: std::option::Option<std::string::String>,
pub(crate) sequence_number_for_ordering: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream to put the data record into.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream to put the data record into.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The data blob to put into the record, which is base64-encoded when the blob is serialized. When the data blob (the payload before base64-encoding) is added to the partition key size, the total size must not exceed the maximum record size (1 MiB).</p>
pub fn data(mut self, input: aws_smithy_types::Blob) -> Self {
self.data = Some(input);
self
}
/// <p>The data blob to put into the record, which is base64-encoded when the blob is serialized. When the data blob (the payload before base64-encoding) is added to the partition key size, the total size must not exceed the maximum record size (1 MiB).</p>
pub fn set_data(mut self, input: std::option::Option<aws_smithy_types::Blob>) -> Self {
self.data = input;
self
}
/// <p>Determines which shard in the stream the data record is assigned to. Partition keys are Unicode strings with a maximum length limit of 256 characters for each key. Amazon Kinesis Data Streams uses the partition key as input to a hash function that maps the partition key and associated data to a specific shard. Specifically, an MD5 hash function is used to map partition keys to 128-bit integer values and to map associated data records to shards. As a result of this hashing mechanism, all data records with the same partition key map to the same shard within the stream.</p>
pub fn partition_key(mut self, input: impl Into<std::string::String>) -> Self {
self.partition_key = Some(input.into());
self
}
/// <p>Determines which shard in the stream the data record is assigned to. Partition keys are Unicode strings with a maximum length limit of 256 characters for each key. Amazon Kinesis Data Streams uses the partition key as input to a hash function that maps the partition key and associated data to a specific shard. Specifically, an MD5 hash function is used to map partition keys to 128-bit integer values and to map associated data records to shards. As a result of this hashing mechanism, all data records with the same partition key map to the same shard within the stream.</p>
pub fn set_partition_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.partition_key = input;
self
}
/// <p>The hash value used to explicitly determine the shard the data record is assigned to by overriding the partition key hash.</p>
pub fn explicit_hash_key(mut self, input: impl Into<std::string::String>) -> Self {
self.explicit_hash_key = Some(input.into());
self
}
/// <p>The hash value used to explicitly determine the shard the data record is assigned to by overriding the partition key hash.</p>
pub fn set_explicit_hash_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.explicit_hash_key = input;
self
}
/// <p>Guarantees strictly increasing sequence numbers, for puts from the same client and to the same partition key. Usage: set the <code>SequenceNumberForOrdering</code> of record <i>n</i> to the sequence number of record <i>n-1</i> (as returned in the result when putting record <i>n-1</i>). If this parameter is not set, records are coarsely ordered based on arrival time.</p>
pub fn sequence_number_for_ordering(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.sequence_number_for_ordering = Some(input.into());
self
}
/// <p>Guarantees strictly increasing sequence numbers, for puts from the same client and to the same partition key. Usage: set the <code>SequenceNumberForOrdering</code> of record <i>n</i> to the sequence number of record <i>n-1</i> (as returned in the result when putting record <i>n-1</i>). If this parameter is not set, records are coarsely ordered based on arrival time.</p>
pub fn set_sequence_number_for_ordering(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.sequence_number_for_ordering = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`PutRecordInput`](crate::input::PutRecordInput).
pub fn build(
self,
) -> Result<crate::input::PutRecordInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::PutRecordInput {
stream_name: self.stream_name,
data: self.data,
partition_key: self.partition_key,
explicit_hash_key: self.explicit_hash_key,
sequence_number_for_ordering: self.sequence_number_for_ordering,
stream_arn: self.stream_arn,
})
}
}
}
impl PutRecordInput {
/// Consumes the builder and constructs an Operation<[`PutRecord`](crate::operation::PutRecord)>
#[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::PutRecord,
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())
.set_operation_type(Some("data".to_string()))
.set_stream_arn(self.stream_arn.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::PutRecordInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutRecordInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.PutRecord",
);
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_record(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::PutRecord::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutRecord",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutRecordInput`](crate::input::PutRecordInput).
pub fn builder() -> crate::input::put_record_input::Builder {
crate::input::put_record_input::Builder::default()
}
}
/// See [`PutRecordsInput`](crate::input::PutRecordsInput).
pub mod put_records_input {
/// A builder for [`PutRecordsInput`](crate::input::PutRecordsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) records:
std::option::Option<std::vec::Vec<crate::model::PutRecordsRequestEntry>>,
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// Appends an item to `records`.
///
/// To override the contents of this collection use [`set_records`](Self::set_records).
///
/// <p>The records associated with the request.</p>
pub fn records(mut self, input: crate::model::PutRecordsRequestEntry) -> Self {
let mut v = self.records.unwrap_or_default();
v.push(input);
self.records = Some(v);
self
}
/// <p>The records associated with the request.</p>
pub fn set_records(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::PutRecordsRequestEntry>>,
) -> Self {
self.records = input;
self
}
/// <p>The stream name associated with the request.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The stream name associated with the request.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`PutRecordsInput`](crate::input::PutRecordsInput).
pub fn build(
self,
) -> Result<crate::input::PutRecordsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::PutRecordsInput {
records: self.records,
stream_name: self.stream_name,
stream_arn: self.stream_arn,
})
}
}
}
impl PutRecordsInput {
/// Consumes the builder and constructs an Operation<[`PutRecords`](crate::operation::PutRecords)>
#[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::PutRecords,
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())
.set_operation_type(Some("data".to_string()))
.set_stream_arn(self.stream_arn.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::PutRecordsInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::PutRecordsInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.PutRecords",
);
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_records(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::PutRecords::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"PutRecords",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`PutRecordsInput`](crate::input::PutRecordsInput).
pub fn builder() -> crate::input::put_records_input::Builder {
crate::input::put_records_input::Builder::default()
}
}
/// See [`RegisterStreamConsumerInput`](crate::input::RegisterStreamConsumerInput).
pub mod register_stream_consumer_input {
/// A builder for [`RegisterStreamConsumerInput`](crate::input::RegisterStreamConsumerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_arn: std::option::Option<std::string::String>,
pub(crate) consumer_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The ARN of the Kinesis data stream that you want to register the consumer with. For more info, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the Kinesis data stream that you want to register the consumer with. For more info, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// <p>For a given Kinesis data stream, each consumer must have a unique name. However, consumer names don't have to be unique across data streams.</p>
pub fn consumer_name(mut self, input: impl Into<std::string::String>) -> Self {
self.consumer_name = Some(input.into());
self
}
/// <p>For a given Kinesis data stream, each consumer must have a unique name. However, consumer names don't have to be unique across data streams.</p>
pub fn set_consumer_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.consumer_name = input;
self
}
/// Consumes the builder and constructs a [`RegisterStreamConsumerInput`](crate::input::RegisterStreamConsumerInput).
pub fn build(
self,
) -> Result<
crate::input::RegisterStreamConsumerInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::RegisterStreamConsumerInput {
stream_arn: self.stream_arn,
consumer_name: self.consumer_name,
})
}
}
}
impl RegisterStreamConsumerInput {
/// Consumes the builder and constructs an Operation<[`RegisterStreamConsumer`](crate::operation::RegisterStreamConsumer)>
#[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::RegisterStreamConsumer,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::RegisterStreamConsumerInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RegisterStreamConsumerInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.RegisterStreamConsumer",
);
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_register_stream_consumer(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::RegisterStreamConsumer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RegisterStreamConsumer",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RegisterStreamConsumerInput`](crate::input::RegisterStreamConsumerInput).
pub fn builder() -> crate::input::register_stream_consumer_input::Builder {
crate::input::register_stream_consumer_input::Builder::default()
}
}
/// See [`RemoveTagsFromStreamInput`](crate::input::RemoveTagsFromStreamInput).
pub mod remove_tags_from_stream_input {
/// A builder for [`RemoveTagsFromStreamInput`](crate::input::RemoveTagsFromStreamInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// Appends an item to `tag_keys`.
///
/// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
///
/// <p>A list of tag keys. Each corresponding tag is removed from the stream.</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>A list of tag keys. Each corresponding tag is removed from the stream.</p>
pub fn set_tag_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tag_keys = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`RemoveTagsFromStreamInput`](crate::input::RemoveTagsFromStreamInput).
pub fn build(
self,
) -> Result<
crate::input::RemoveTagsFromStreamInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::RemoveTagsFromStreamInput {
stream_name: self.stream_name,
tag_keys: self.tag_keys,
stream_arn: self.stream_arn,
})
}
}
}
impl RemoveTagsFromStreamInput {
/// Consumes the builder and constructs an Operation<[`RemoveTagsFromStream`](crate::operation::RemoveTagsFromStream)>
#[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::RemoveTagsFromStream,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::RemoveTagsFromStreamInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::RemoveTagsFromStreamInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.RemoveTagsFromStream",
);
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_remove_tags_from_stream(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::RemoveTagsFromStream::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"RemoveTagsFromStream",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`RemoveTagsFromStreamInput`](crate::input::RemoveTagsFromStreamInput).
pub fn builder() -> crate::input::remove_tags_from_stream_input::Builder {
crate::input::remove_tags_from_stream_input::Builder::default()
}
}
/// See [`SplitShardInput`](crate::input::SplitShardInput).
pub mod split_shard_input {
/// A builder for [`SplitShardInput`](crate::input::SplitShardInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) shard_to_split: std::option::Option<std::string::String>,
pub(crate) new_starting_hash_key: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream for the shard split.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream for the shard split.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The shard ID of the shard to split.</p>
pub fn shard_to_split(mut self, input: impl Into<std::string::String>) -> Self {
self.shard_to_split = Some(input.into());
self
}
/// <p>The shard ID of the shard to split.</p>
pub fn set_shard_to_split(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.shard_to_split = input;
self
}
/// <p>A hash key value for the starting hash key of one of the child shards created by the split. The hash key range for a given shard constitutes a set of ordered contiguous positive integers. The value for <code>NewStartingHashKey</code> must be in the range of hash keys being mapped into the shard. The <code>NewStartingHashKey</code> hash key value and all higher hash key values in hash key range are distributed to one of the child shards. All the lower hash key values in the range are distributed to the other child shard.</p>
pub fn new_starting_hash_key(mut self, input: impl Into<std::string::String>) -> Self {
self.new_starting_hash_key = Some(input.into());
self
}
/// <p>A hash key value for the starting hash key of one of the child shards created by the split. The hash key range for a given shard constitutes a set of ordered contiguous positive integers. The value for <code>NewStartingHashKey</code> must be in the range of hash keys being mapped into the shard. The <code>NewStartingHashKey</code> hash key value and all higher hash key values in hash key range are distributed to one of the child shards. All the lower hash key values in the range are distributed to the other child shard.</p>
pub fn set_new_starting_hash_key(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.new_starting_hash_key = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`SplitShardInput`](crate::input::SplitShardInput).
pub fn build(
self,
) -> Result<crate::input::SplitShardInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::SplitShardInput {
stream_name: self.stream_name,
shard_to_split: self.shard_to_split,
new_starting_hash_key: self.new_starting_hash_key,
stream_arn: self.stream_arn,
})
}
}
}
impl SplitShardInput {
/// Consumes the builder and constructs an Operation<[`SplitShard`](crate::operation::SplitShard)>
#[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::SplitShard,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::SplitShardInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::SplitShardInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.SplitShard",
);
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_split_shard(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::SplitShard::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SplitShard",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`SplitShardInput`](crate::input::SplitShardInput).
pub fn builder() -> crate::input::split_shard_input::Builder {
crate::input::split_shard_input::Builder::default()
}
}
/// See [`StartStreamEncryptionInput`](crate::input::StartStreamEncryptionInput).
pub mod start_stream_encryption_input {
/// A builder for [`StartStreamEncryptionInput`](crate::input::StartStreamEncryptionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) encryption_type: std::option::Option<crate::model::EncryptionType>,
pub(crate) key_id: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream for which to start encrypting records.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream for which to start encrypting records.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The encryption type to use. The only valid value is <code>KMS</code>.</p>
pub fn encryption_type(mut self, input: crate::model::EncryptionType) -> Self {
self.encryption_type = Some(input);
self
}
/// <p>The encryption type to use. The only valid value is <code>KMS</code>.</p>
pub fn set_encryption_type(
mut self,
input: std::option::Option<crate::model::EncryptionType>,
) -> Self {
self.encryption_type = input;
self
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.key_id = Some(input.into());
self
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn set_key_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key_id = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`StartStreamEncryptionInput`](crate::input::StartStreamEncryptionInput).
pub fn build(
self,
) -> Result<
crate::input::StartStreamEncryptionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartStreamEncryptionInput {
stream_name: self.stream_name,
encryption_type: self.encryption_type,
key_id: self.key_id,
stream_arn: self.stream_arn,
})
}
}
}
impl StartStreamEncryptionInput {
/// Consumes the builder and constructs an Operation<[`StartStreamEncryption`](crate::operation::StartStreamEncryption)>
#[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::StartStreamEncryption,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::StartStreamEncryptionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StartStreamEncryptionInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.StartStreamEncryption",
);
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_stream_encryption(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::StartStreamEncryption::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartStreamEncryption",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartStreamEncryptionInput`](crate::input::StartStreamEncryptionInput).
pub fn builder() -> crate::input::start_stream_encryption_input::Builder {
crate::input::start_stream_encryption_input::Builder::default()
}
}
/// See [`StopStreamEncryptionInput`](crate::input::StopStreamEncryptionInput).
pub mod stop_stream_encryption_input {
/// A builder for [`StopStreamEncryptionInput`](crate::input::StopStreamEncryptionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) encryption_type: std::option::Option<crate::model::EncryptionType>,
pub(crate) key_id: std::option::Option<std::string::String>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream on which to stop encrypting records.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream on which to stop encrypting records.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The encryption type. The only valid value is <code>KMS</code>.</p>
pub fn encryption_type(mut self, input: crate::model::EncryptionType) -> Self {
self.encryption_type = Some(input);
self
}
/// <p>The encryption type. The only valid value is <code>KMS</code>.</p>
pub fn set_encryption_type(
mut self,
input: std::option::Option<crate::model::EncryptionType>,
) -> Self {
self.encryption_type = input;
self
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.key_id = Some(input.into());
self
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn set_key_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.key_id = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`StopStreamEncryptionInput`](crate::input::StopStreamEncryptionInput).
pub fn build(
self,
) -> Result<
crate::input::StopStreamEncryptionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StopStreamEncryptionInput {
stream_name: self.stream_name,
encryption_type: self.encryption_type,
key_id: self.key_id,
stream_arn: self.stream_arn,
})
}
}
}
impl StopStreamEncryptionInput {
/// Consumes the builder and constructs an Operation<[`StopStreamEncryption`](crate::operation::StopStreamEncryption)>
#[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::StopStreamEncryption,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::StopStreamEncryptionInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::StopStreamEncryptionInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.StopStreamEncryption",
);
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_stop_stream_encryption(
&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::StopStreamEncryption::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopStreamEncryption",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopStreamEncryptionInput`](crate::input::StopStreamEncryptionInput).
pub fn builder() -> crate::input::stop_stream_encryption_input::Builder {
crate::input::stop_stream_encryption_input::Builder::default()
}
}
/// See [`UpdateShardCountInput`](crate::input::UpdateShardCountInput).
pub mod update_shard_count_input {
/// A builder for [`UpdateShardCountInput`](crate::input::UpdateShardCountInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_name: std::option::Option<std::string::String>,
pub(crate) target_shard_count: std::option::Option<i32>,
pub(crate) scaling_type: std::option::Option<crate::model::ScalingType>,
pub(crate) stream_arn: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The name of the stream.</p>
pub fn stream_name(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_name = Some(input.into());
self
}
/// <p>The name of the stream.</p>
pub fn set_stream_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_name = input;
self
}
/// <p>The new number of shards. This value has the following default limits. By default, you cannot do the following: </p>
/// <ul>
/// <li> <p>Set this value to more than double your current shard count for a stream.</p> </li>
/// <li> <p>Set this value below half your current shard count for a stream.</p> </li>
/// <li> <p>Set this value to more than 10000 shards in a stream (the default limit for shard count per stream is 10000 per account per region), unless you request a limit increase.</p> </li>
/// <li> <p>Scale a stream with more than 10000 shards down unless you set this value to less than 10000 shards.</p> </li>
/// </ul>
pub fn target_shard_count(mut self, input: i32) -> Self {
self.target_shard_count = Some(input);
self
}
/// <p>The new number of shards. This value has the following default limits. By default, you cannot do the following: </p>
/// <ul>
/// <li> <p>Set this value to more than double your current shard count for a stream.</p> </li>
/// <li> <p>Set this value below half your current shard count for a stream.</p> </li>
/// <li> <p>Set this value to more than 10000 shards in a stream (the default limit for shard count per stream is 10000 per account per region), unless you request a limit increase.</p> </li>
/// <li> <p>Scale a stream with more than 10000 shards down unless you set this value to less than 10000 shards.</p> </li>
/// </ul>
pub fn set_target_shard_count(mut self, input: std::option::Option<i32>) -> Self {
self.target_shard_count = input;
self
}
/// <p>The scaling type. Uniform scaling creates shards of equal size.</p>
pub fn scaling_type(mut self, input: crate::model::ScalingType) -> Self {
self.scaling_type = Some(input);
self
}
/// <p>The scaling type. Uniform scaling creates shards of equal size.</p>
pub fn set_scaling_type(
mut self,
input: std::option::Option<crate::model::ScalingType>,
) -> Self {
self.scaling_type = input;
self
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p>The ARN of the stream.</p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// Consumes the builder and constructs a [`UpdateShardCountInput`](crate::input::UpdateShardCountInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateShardCountInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateShardCountInput {
stream_name: self.stream_name,
target_shard_count: self.target_shard_count,
scaling_type: self.scaling_type,
stream_arn: self.stream_arn,
})
}
}
}
impl UpdateShardCountInput {
/// Consumes the builder and constructs an Operation<[`UpdateShardCount`](crate::operation::UpdateShardCount)>
#[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::UpdateShardCount,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::UpdateShardCountInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateShardCountInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.UpdateShardCount",
);
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_shard_count(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::UpdateShardCount::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateShardCount",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateShardCountInput`](crate::input::UpdateShardCountInput).
pub fn builder() -> crate::input::update_shard_count_input::Builder {
crate::input::update_shard_count_input::Builder::default()
}
}
/// See [`UpdateStreamModeInput`](crate::input::UpdateStreamModeInput).
pub mod update_stream_mode_input {
/// A builder for [`UpdateStreamModeInput`](crate::input::UpdateStreamModeInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stream_arn: std::option::Option<std::string::String>,
pub(crate) stream_mode_details: std::option::Option<crate::model::StreamModeDetails>,
}
impl Builder {
/// <p> Specifies the ARN of the data stream whose capacity mode you want to update. </p>
pub fn stream_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.stream_arn = Some(input.into());
self
}
/// <p> Specifies the ARN of the data stream whose capacity mode you want to update. </p>
pub fn set_stream_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.stream_arn = input;
self
}
/// <p> Specifies the capacity mode to which you want to set your data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams. </p>
pub fn stream_mode_details(mut self, input: crate::model::StreamModeDetails) -> Self {
self.stream_mode_details = Some(input);
self
}
/// <p> Specifies the capacity mode to which you want to set your data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams. </p>
pub fn set_stream_mode_details(
mut self,
input: std::option::Option<crate::model::StreamModeDetails>,
) -> Self {
self.stream_mode_details = input;
self
}
/// Consumes the builder and constructs a [`UpdateStreamModeInput`](crate::input::UpdateStreamModeInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateStreamModeInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateStreamModeInput {
stream_arn: self.stream_arn,
stream_mode_details: self.stream_mode_details,
})
}
}
}
impl UpdateStreamModeInput {
/// Consumes the builder and constructs an Operation<[`UpdateStreamMode`](crate::operation::UpdateStreamMode)>
#[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::UpdateStreamMode,
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())
.set_operation_type(Some("control".to_string()))
.set_stream_arn(self.stream_arn.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::UpdateStreamModeInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UpdateStreamModeInput,
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/x-amz-json-1.1",
);
builder = aws_smithy_http::header::set_request_header_if_absent(
builder,
http::header::HeaderName::from_static("x-amz-target"),
"Kinesis_20131202.UpdateStreamMode",
);
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_stream_mode(&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(vec![http::Version::HTTP_11, http::Version::HTTP_2]);
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::UpdateStreamMode::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateStreamMode",
"kinesis",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateStreamModeInput`](crate::input::UpdateStreamModeInput).
pub fn builder() -> crate::input::update_stream_mode_input::Builder {
crate::input::update_stream_mode_input::Builder::default()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateStreamModeInput {
/// <p> Specifies the ARN of the data stream whose capacity mode you want to update. </p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
/// <p> Specifies the capacity mode to which you want to set your data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams. </p>
#[doc(hidden)]
pub stream_mode_details: std::option::Option<crate::model::StreamModeDetails>,
}
impl UpdateStreamModeInput {
/// <p> Specifies the ARN of the data stream whose capacity mode you want to update. </p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
/// <p> Specifies the capacity mode to which you want to set your data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams. </p>
pub fn stream_mode_details(&self) -> std::option::Option<&crate::model::StreamModeDetails> {
self.stream_mode_details.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateShardCountInput {
/// <p>The name of the stream.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The new number of shards. This value has the following default limits. By default, you cannot do the following: </p>
/// <ul>
/// <li> <p>Set this value to more than double your current shard count for a stream.</p> </li>
/// <li> <p>Set this value below half your current shard count for a stream.</p> </li>
/// <li> <p>Set this value to more than 10000 shards in a stream (the default limit for shard count per stream is 10000 per account per region), unless you request a limit increase.</p> </li>
/// <li> <p>Scale a stream with more than 10000 shards down unless you set this value to less than 10000 shards.</p> </li>
/// </ul>
#[doc(hidden)]
pub target_shard_count: std::option::Option<i32>,
/// <p>The scaling type. Uniform scaling creates shards of equal size.</p>
#[doc(hidden)]
pub scaling_type: std::option::Option<crate::model::ScalingType>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl UpdateShardCountInput {
/// <p>The name of the stream.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The new number of shards. This value has the following default limits. By default, you cannot do the following: </p>
/// <ul>
/// <li> <p>Set this value to more than double your current shard count for a stream.</p> </li>
/// <li> <p>Set this value below half your current shard count for a stream.</p> </li>
/// <li> <p>Set this value to more than 10000 shards in a stream (the default limit for shard count per stream is 10000 per account per region), unless you request a limit increase.</p> </li>
/// <li> <p>Scale a stream with more than 10000 shards down unless you set this value to less than 10000 shards.</p> </li>
/// </ul>
pub fn target_shard_count(&self) -> std::option::Option<i32> {
self.target_shard_count
}
/// <p>The scaling type. Uniform scaling creates shards of equal size.</p>
pub fn scaling_type(&self) -> std::option::Option<&crate::model::ScalingType> {
self.scaling_type.as_ref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopStreamEncryptionInput {
/// <p>The name of the stream on which to stop encrypting records.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The encryption type. The only valid value is <code>KMS</code>.</p>
#[doc(hidden)]
pub encryption_type: std::option::Option<crate::model::EncryptionType>,
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
#[doc(hidden)]
pub key_id: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl StopStreamEncryptionInput {
/// <p>The name of the stream on which to stop encrypting records.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The encryption type. The only valid value is <code>KMS</code>.</p>
pub fn encryption_type(&self) -> std::option::Option<&crate::model::EncryptionType> {
self.encryption_type.as_ref()
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn key_id(&self) -> std::option::Option<&str> {
self.key_id.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartStreamEncryptionInput {
/// <p>The name of the stream for which to start encrypting records.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The encryption type to use. The only valid value is <code>KMS</code>.</p>
#[doc(hidden)]
pub encryption_type: std::option::Option<crate::model::EncryptionType>,
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
#[doc(hidden)]
pub key_id: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl StartStreamEncryptionInput {
/// <p>The name of the stream for which to start encrypting records.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The encryption type to use. The only valid value is <code>KMS</code>.</p>
pub fn encryption_type(&self) -> std::option::Option<&crate::model::EncryptionType> {
self.encryption_type.as_ref()
}
/// <p>The GUID for the customer-managed Amazon Web Services KMS key to use for encryption. This value can be a globally unique identifier, a fully specified Amazon Resource Name (ARN) to either an alias or a key, or an alias name prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams by specifying the alias <code>aws/kinesis</code>.</p>
/// <ul>
/// <li> <p>Key ARN example: <code>arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias ARN example: <code>arn:aws:kms:us-east-1:123456789012:alias/MyAliasName</code> </p> </li>
/// <li> <p>Globally unique key ID example: <code>12345678-1234-1234-1234-123456789012</code> </p> </li>
/// <li> <p>Alias name example: <code>alias/MyAliasName</code> </p> </li>
/// <li> <p>Master key owned by Kinesis Data Streams: <code>alias/aws/kinesis</code> </p> </li>
/// </ul>
pub fn key_id(&self) -> std::option::Option<&str> {
self.key_id.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>SplitShard</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SplitShardInput {
/// <p>The name of the stream for the shard split.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The shard ID of the shard to split.</p>
#[doc(hidden)]
pub shard_to_split: std::option::Option<std::string::String>,
/// <p>A hash key value for the starting hash key of one of the child shards created by the split. The hash key range for a given shard constitutes a set of ordered contiguous positive integers. The value for <code>NewStartingHashKey</code> must be in the range of hash keys being mapped into the shard. The <code>NewStartingHashKey</code> hash key value and all higher hash key values in hash key range are distributed to one of the child shards. All the lower hash key values in the range are distributed to the other child shard.</p>
#[doc(hidden)]
pub new_starting_hash_key: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl SplitShardInput {
/// <p>The name of the stream for the shard split.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The shard ID of the shard to split.</p>
pub fn shard_to_split(&self) -> std::option::Option<&str> {
self.shard_to_split.as_deref()
}
/// <p>A hash key value for the starting hash key of one of the child shards created by the split. The hash key range for a given shard constitutes a set of ordered contiguous positive integers. The value for <code>NewStartingHashKey</code> must be in the range of hash keys being mapped into the shard. The <code>NewStartingHashKey</code> hash key value and all higher hash key values in hash key range are distributed to one of the child shards. All the lower hash key values in the range are distributed to the other child shard.</p>
pub fn new_starting_hash_key(&self) -> std::option::Option<&str> {
self.new_starting_hash_key.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>RemoveTagsFromStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RemoveTagsFromStreamInput {
/// <p>The name of the stream.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>A list of tag keys. Each corresponding tag is removed from the stream.</p>
#[doc(hidden)]
pub tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl RemoveTagsFromStreamInput {
/// <p>The name of the stream.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>A list of tag keys. Each corresponding tag is removed from the stream.</p>
pub fn tag_keys(&self) -> std::option::Option<&[std::string::String]> {
self.tag_keys.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RegisterStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that you want to register the consumer with. For more info, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
/// <p>For a given Kinesis data stream, each consumer must have a unique name. However, consumer names don't have to be unique across data streams.</p>
#[doc(hidden)]
pub consumer_name: std::option::Option<std::string::String>,
}
impl RegisterStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that you want to register the consumer with. For more info, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
/// <p>For a given Kinesis data stream, each consumer must have a unique name. However, consumer names don't have to be unique across data streams.</p>
pub fn consumer_name(&self) -> std::option::Option<&str> {
self.consumer_name.as_deref()
}
}
/// <p>A <code>PutRecords</code> request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutRecordsInput {
/// <p>The records associated with the request.</p>
#[doc(hidden)]
pub records: std::option::Option<std::vec::Vec<crate::model::PutRecordsRequestEntry>>,
/// <p>The stream name associated with the request.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl PutRecordsInput {
/// <p>The records associated with the request.</p>
pub fn records(&self) -> std::option::Option<&[crate::model::PutRecordsRequestEntry]> {
self.records.as_deref()
}
/// <p>The stream name associated with the request.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>PutRecord</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutRecordInput {
/// <p>The name of the stream to put the data record into.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The data blob to put into the record, which is base64-encoded when the blob is serialized. When the data blob (the payload before base64-encoding) is added to the partition key size, the total size must not exceed the maximum record size (1 MiB).</p>
#[doc(hidden)]
pub data: std::option::Option<aws_smithy_types::Blob>,
/// <p>Determines which shard in the stream the data record is assigned to. Partition keys are Unicode strings with a maximum length limit of 256 characters for each key. Amazon Kinesis Data Streams uses the partition key as input to a hash function that maps the partition key and associated data to a specific shard. Specifically, an MD5 hash function is used to map partition keys to 128-bit integer values and to map associated data records to shards. As a result of this hashing mechanism, all data records with the same partition key map to the same shard within the stream.</p>
#[doc(hidden)]
pub partition_key: std::option::Option<std::string::String>,
/// <p>The hash value used to explicitly determine the shard the data record is assigned to by overriding the partition key hash.</p>
#[doc(hidden)]
pub explicit_hash_key: std::option::Option<std::string::String>,
/// <p>Guarantees strictly increasing sequence numbers, for puts from the same client and to the same partition key. Usage: set the <code>SequenceNumberForOrdering</code> of record <i>n</i> to the sequence number of record <i>n-1</i> (as returned in the result when putting record <i>n-1</i>). If this parameter is not set, records are coarsely ordered based on arrival time.</p>
#[doc(hidden)]
pub sequence_number_for_ordering: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl PutRecordInput {
/// <p>The name of the stream to put the data record into.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The data blob to put into the record, which is base64-encoded when the blob is serialized. When the data blob (the payload before base64-encoding) is added to the partition key size, the total size must not exceed the maximum record size (1 MiB).</p>
pub fn data(&self) -> std::option::Option<&aws_smithy_types::Blob> {
self.data.as_ref()
}
/// <p>Determines which shard in the stream the data record is assigned to. Partition keys are Unicode strings with a maximum length limit of 256 characters for each key. Amazon Kinesis Data Streams uses the partition key as input to a hash function that maps the partition key and associated data to a specific shard. Specifically, an MD5 hash function is used to map partition keys to 128-bit integer values and to map associated data records to shards. As a result of this hashing mechanism, all data records with the same partition key map to the same shard within the stream.</p>
pub fn partition_key(&self) -> std::option::Option<&str> {
self.partition_key.as_deref()
}
/// <p>The hash value used to explicitly determine the shard the data record is assigned to by overriding the partition key hash.</p>
pub fn explicit_hash_key(&self) -> std::option::Option<&str> {
self.explicit_hash_key.as_deref()
}
/// <p>Guarantees strictly increasing sequence numbers, for puts from the same client and to the same partition key. Usage: set the <code>SequenceNumberForOrdering</code> of record <i>n</i> to the sequence number of record <i>n-1</i> (as returned in the result when putting record <i>n-1</i>). If this parameter is not set, records are coarsely ordered based on arrival time.</p>
pub fn sequence_number_for_ordering(&self) -> std::option::Option<&str> {
self.sequence_number_for_ordering.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>MergeShards</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct MergeShardsInput {
/// <p>The name of the stream for the merge.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The shard ID of the shard to combine with the adjacent shard for the merge.</p>
#[doc(hidden)]
pub shard_to_merge: std::option::Option<std::string::String>,
/// <p>The shard ID of the adjacent shard for the merge.</p>
#[doc(hidden)]
pub adjacent_shard_to_merge: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl MergeShardsInput {
/// <p>The name of the stream for the merge.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The shard ID of the shard to combine with the adjacent shard for the merge.</p>
pub fn shard_to_merge(&self) -> std::option::Option<&str> {
self.shard_to_merge.as_deref()
}
/// <p>The shard ID of the adjacent shard for the merge.</p>
pub fn adjacent_shard_to_merge(&self) -> std::option::Option<&str> {
self.adjacent_shard_to_merge.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>ListTagsForStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForStreamInput {
/// <p>The name of the stream.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The key to use as the starting point for the list of tags. If this parameter is set, <code>ListTagsForStream</code> gets all tags that occur after <code>ExclusiveStartTagKey</code>. </p>
#[doc(hidden)]
pub exclusive_start_tag_key: std::option::Option<std::string::String>,
/// <p>The number of tags to return. If this number is less than the total number of tags associated with the stream, <code>HasMoreTags</code> is set to <code>true</code>. To list additional tags, set <code>ExclusiveStartTagKey</code> to the last key in the response.</p>
#[doc(hidden)]
pub limit: std::option::Option<i32>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl ListTagsForStreamInput {
/// <p>The name of the stream.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The key to use as the starting point for the list of tags. If this parameter is set, <code>ListTagsForStream</code> gets all tags that occur after <code>ExclusiveStartTagKey</code>. </p>
pub fn exclusive_start_tag_key(&self) -> std::option::Option<&str> {
self.exclusive_start_tag_key.as_deref()
}
/// <p>The number of tags to return. If this number is less than the total number of tags associated with the stream, <code>HasMoreTags</code> is set to <code>true</code>. To list additional tags, set <code>ExclusiveStartTagKey</code> to the last key in the response.</p>
pub fn limit(&self) -> std::option::Option<i32> {
self.limit
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>ListStreams</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListStreamsInput {
/// <p>The maximum number of streams to list. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
#[doc(hidden)]
pub limit: std::option::Option<i32>,
/// <p>The name of the stream to start the list with.</p>
#[doc(hidden)]
pub exclusive_start_stream_name: std::option::Option<std::string::String>,
/// <p></p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListStreamsInput {
/// <p>The maximum number of streams to list. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn limit(&self) -> std::option::Option<i32> {
self.limit
}
/// <p>The name of the stream to start the list with.</p>
pub fn exclusive_start_stream_name(&self) -> std::option::Option<&str> {
self.exclusive_start_stream_name.as_deref()
}
/// <p></p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListStreamConsumersInput {
/// <p>The ARN of the Kinesis data stream for which you want to list the registered consumers. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
/// <p>When the number of consumers that are registered with the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of consumers that are registered with the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListStreamConsumers</code> to list the next set of registered consumers.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of consumers that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListStreamConsumers</code> operation to list the next set of consumers.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListStreamConsumers</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListStreamConsumers</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The maximum number of consumers that you want a single call of <code>ListStreamConsumers</code> to return. The default value is 100. If you specify a value greater than 100, at most 100 results are returned. </p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the consumers for. </p>
/// <p>You can't specify this parameter if you specify the NextToken parameter. </p>
#[doc(hidden)]
pub stream_creation_timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl ListStreamConsumersInput {
/// <p>The ARN of the Kinesis data stream for which you want to list the registered consumers. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
/// <p>When the number of consumers that are registered with the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of consumers that are registered with the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListStreamConsumers</code> to list the next set of registered consumers.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of consumers that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListStreamConsumers</code> operation to list the next set of consumers.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListStreamConsumers</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListStreamConsumers</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The maximum number of consumers that you want a single call of <code>ListStreamConsumers</code> to return. The default value is 100. If you specify a value greater than 100, at most 100 results are returned. </p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the consumers for. </p>
/// <p>You can't specify this parameter if you specify the NextToken parameter. </p>
pub fn stream_creation_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.stream_creation_timestamp.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListShardsInput {
/// <p>The name of the data stream whose shards you want to list. </p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>When the number of shards in the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of shards in the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of shards that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListShards</code> operation.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListShards</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListShards</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>Specify this parameter to indicate that you want to list the shards starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior is for <code>ListShards</code> to list the shards starting with the first one in the stream.</p>
/// <p>You cannot specify this parameter if you specify <code>NextToken</code>.</p>
#[doc(hidden)]
pub exclusive_start_shard_id: std::option::Option<std::string::String>,
/// <p>The maximum number of shards to return in a single call to <code>ListShards</code>. The maximum number of shards to return in a single call. The default value is 1000. If you specify a value greater than 1000, at most 1000 results are returned. </p>
/// <p>When the number of shards to be listed is greater than the value of <code>MaxResults</code>, the response contains a <code>NextToken</code> value that you can use in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the shards for.</p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
#[doc(hidden)]
pub stream_creation_timestamp: std::option::Option<aws_smithy_types::DateTime>,
/// <p>Enables you to filter out the response of the <code>ListShards</code> API. You can only specify one filter at a time. </p>
/// <p>If you use the <code>ShardFilter</code> parameter when invoking the ListShards API, the <code>Type</code> is the required property and must be specified. If you specify the <code>AT_TRIM_HORIZON</code>, <code>FROM_TRIM_HORIZON</code>, or <code>AT_LATEST</code> types, you do not need to specify either the <code>ShardId</code> or the <code>Timestamp</code> optional properties. </p>
/// <p>If you specify the <code>AFTER_SHARD_ID</code> type, you must also provide the value for the optional <code>ShardId</code> property. The <code>ShardId</code> property is identical in fuctionality to the <code>ExclusiveStartShardId</code> parameter of the <code>ListShards</code> API. When <code>ShardId</code> property is specified, the response includes the shards starting with the shard whose ID immediately follows the <code>ShardId</code> that you provided. </p>
/// <p>If you specify the <code>AT_TIMESTAMP</code> or <code>FROM_TIMESTAMP_ID</code> type, you must also provide the value for the optional <code>Timestamp</code> property. If you specify the AT_TIMESTAMP type, then all shards that were open at the provided timestamp are returned. If you specify the FROM_TIMESTAMP type, then all shards starting from the provided timestamp to TIP are returned. </p>
#[doc(hidden)]
pub shard_filter: std::option::Option<crate::model::ShardFilter>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl ListShardsInput {
/// <p>The name of the data stream whose shards you want to list. </p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>When the number of shards in the data stream is greater than the default value for the <code>MaxResults</code> parameter, or if you explicitly specify a value for <code>MaxResults</code> that is less than the number of shards in the data stream, the response includes a pagination token named <code>NextToken</code>. You can specify this <code>NextToken</code> value in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
/// <p>Don't specify <code>StreamName</code> or <code>StreamCreationTimestamp</code> if you specify <code>NextToken</code> because the latter unambiguously identifies the stream.</p>
/// <p>You can optionally specify a value for the <code>MaxResults</code> parameter when you specify <code>NextToken</code>. If you specify a <code>MaxResults</code> value that is less than the number of shards that the operation returns if you don't specify <code>MaxResults</code>, the response will contain a new <code>NextToken</code> value. You can use the new <code>NextToken</code> value in a subsequent call to the <code>ListShards</code> operation.</p> <important>
/// <p>Tokens expire after 300 seconds. When you obtain a value for <code>NextToken</code> in the response to a call to <code>ListShards</code>, you have 300 seconds to use that value. If you specify an expired token in a call to <code>ListShards</code>, you get <code>ExpiredNextTokenException</code>.</p>
/// </important>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>Specify this parameter to indicate that you want to list the shards starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior is for <code>ListShards</code> to list the shards starting with the first one in the stream.</p>
/// <p>You cannot specify this parameter if you specify <code>NextToken</code>.</p>
pub fn exclusive_start_shard_id(&self) -> std::option::Option<&str> {
self.exclusive_start_shard_id.as_deref()
}
/// <p>The maximum number of shards to return in a single call to <code>ListShards</code>. The maximum number of shards to return in a single call. The default value is 1000. If you specify a value greater than 1000, at most 1000 results are returned. </p>
/// <p>When the number of shards to be listed is greater than the value of <code>MaxResults</code>, the response contains a <code>NextToken</code> value that you can use in a subsequent call to <code>ListShards</code> to list the next set of shards.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>Specify this input parameter to distinguish data streams that have the same name. For example, if you create a data stream and then delete it, and you later create another data stream with the same name, you can use this input parameter to specify which of the two streams you want to list the shards for.</p>
/// <p>You cannot specify this parameter if you specify the <code>NextToken</code> parameter.</p>
pub fn stream_creation_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.stream_creation_timestamp.as_ref()
}
/// <p>Enables you to filter out the response of the <code>ListShards</code> API. You can only specify one filter at a time. </p>
/// <p>If you use the <code>ShardFilter</code> parameter when invoking the ListShards API, the <code>Type</code> is the required property and must be specified. If you specify the <code>AT_TRIM_HORIZON</code>, <code>FROM_TRIM_HORIZON</code>, or <code>AT_LATEST</code> types, you do not need to specify either the <code>ShardId</code> or the <code>Timestamp</code> optional properties. </p>
/// <p>If you specify the <code>AFTER_SHARD_ID</code> type, you must also provide the value for the optional <code>ShardId</code> property. The <code>ShardId</code> property is identical in fuctionality to the <code>ExclusiveStartShardId</code> parameter of the <code>ListShards</code> API. When <code>ShardId</code> property is specified, the response includes the shards starting with the shard whose ID immediately follows the <code>ShardId</code> that you provided. </p>
/// <p>If you specify the <code>AT_TIMESTAMP</code> or <code>FROM_TIMESTAMP_ID</code> type, you must also provide the value for the optional <code>Timestamp</code> property. If you specify the AT_TIMESTAMP type, then all shards that were open at the provided timestamp are returned. If you specify the FROM_TIMESTAMP type, then all shards starting from the provided timestamp to TIP are returned. </p>
pub fn shard_filter(&self) -> std::option::Option<&crate::model::ShardFilter> {
self.shard_filter.as_ref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>IncreaseStreamRetentionPeriod</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct IncreaseStreamRetentionPeriodInput {
/// <p>The name of the stream to modify.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The new retention period of the stream, in hours. Must be more than the current retention period.</p>
#[doc(hidden)]
pub retention_period_hours: std::option::Option<i32>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl IncreaseStreamRetentionPeriodInput {
/// <p>The name of the stream to modify.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The new retention period of the stream, in hours. Must be more than the current retention period.</p>
pub fn retention_period_hours(&self) -> std::option::Option<i32> {
self.retention_period_hours
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>GetShardIterator</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetShardIteratorInput {
/// <p>The name of the Amazon Kinesis data stream.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The shard ID of the Kinesis Data Streams shard to get the iterator for.</p>
#[doc(hidden)]
pub shard_id: std::option::Option<std::string::String>,
/// <p>Determines how the shard iterator is used to start reading data records from the shard.</p>
/// <p>The following are the valid Amazon Kinesis shard iterator types:</p>
/// <ul>
/// <li> <p>AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AT_TIMESTAMP - Start reading from the position denoted by a specific time stamp, provided in the value <code>Timestamp</code>.</p> </li>
/// <li> <p>TRIM_HORIZON - Start reading at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.</p> </li>
/// <li> <p>LATEST - Start reading just after the most recent record in the shard, so that you always read the most recent data in the shard.</p> </li>
/// </ul>
#[doc(hidden)]
pub shard_iterator_type: std::option::Option<crate::model::ShardIteratorType>,
/// <p>The sequence number of the data record in the shard from which to start reading. Used with shard iterator type AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER.</p>
#[doc(hidden)]
pub starting_sequence_number: std::option::Option<std::string::String>,
/// <p>The time stamp of the data record from which to start reading. Used with shard iterator type AT_TIMESTAMP. A time stamp is the Unix epoch date with precision in milliseconds. For example, <code>2016-04-04T19:58:46.480-00:00</code> or <code>1459799926.480</code>. If a record with this exact time stamp does not exist, the iterator returned is for the next (later) record. If the time stamp is older than the current trim horizon, the iterator returned is for the oldest untrimmed data record (TRIM_HORIZON).</p>
#[doc(hidden)]
pub timestamp: std::option::Option<aws_smithy_types::DateTime>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl GetShardIteratorInput {
/// <p>The name of the Amazon Kinesis data stream.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The shard ID of the Kinesis Data Streams shard to get the iterator for.</p>
pub fn shard_id(&self) -> std::option::Option<&str> {
self.shard_id.as_deref()
}
/// <p>Determines how the shard iterator is used to start reading data records from the shard.</p>
/// <p>The following are the valid Amazon Kinesis shard iterator types:</p>
/// <ul>
/// <li> <p>AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted by a specific sequence number, provided in the value <code>StartingSequenceNumber</code>.</p> </li>
/// <li> <p>AT_TIMESTAMP - Start reading from the position denoted by a specific time stamp, provided in the value <code>Timestamp</code>.</p> </li>
/// <li> <p>TRIM_HORIZON - Start reading at the last untrimmed record in the shard in the system, which is the oldest data record in the shard.</p> </li>
/// <li> <p>LATEST - Start reading just after the most recent record in the shard, so that you always read the most recent data in the shard.</p> </li>
/// </ul>
pub fn shard_iterator_type(&self) -> std::option::Option<&crate::model::ShardIteratorType> {
self.shard_iterator_type.as_ref()
}
/// <p>The sequence number of the data record in the shard from which to start reading. Used with shard iterator type AT_SEQUENCE_NUMBER and AFTER_SEQUENCE_NUMBER.</p>
pub fn starting_sequence_number(&self) -> std::option::Option<&str> {
self.starting_sequence_number.as_deref()
}
/// <p>The time stamp of the data record from which to start reading. Used with shard iterator type AT_TIMESTAMP. A time stamp is the Unix epoch date with precision in milliseconds. For example, <code>2016-04-04T19:58:46.480-00:00</code> or <code>1459799926.480</code>. If a record with this exact time stamp does not exist, the iterator returned is for the next (later) record. If the time stamp is older than the current trim horizon, the iterator returned is for the oldest untrimmed data record (TRIM_HORIZON).</p>
pub fn timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.timestamp.as_ref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>GetRecords</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetRecordsInput {
/// <p>The position in the shard from which you want to start sequentially reading data records. A shard iterator specifies this position using the sequence number of a data record in the shard.</p>
#[doc(hidden)]
pub shard_iterator: std::option::Option<std::string::String>,
/// <p>The maximum number of records to return. Specify a value of up to 10,000. If you specify a value that is greater than 10,000, <code>GetRecords</code> throws <code>InvalidArgumentException</code>. The default value is 10,000.</p>
#[doc(hidden)]
pub limit: std::option::Option<i32>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl GetRecordsInput {
/// <p>The position in the shard from which you want to start sequentially reading data records. A shard iterator specifies this position using the sequence number of a data record in the shard.</p>
pub fn shard_iterator(&self) -> std::option::Option<&str> {
self.shard_iterator.as_deref()
}
/// <p>The maximum number of records to return. Specify a value of up to 10,000. If you specify a value that is greater than 10,000, <code>GetRecords</code> throws <code>InvalidArgumentException</code>. The default value is 10,000.</p>
pub fn limit(&self) -> std::option::Option<i32> {
self.limit
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>EnableEnhancedMonitoring</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct EnableEnhancedMonitoringInput {
/// <p>The name of the stream for which to enable enhanced monitoring.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>List of shard-level metrics to enable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" enables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
#[doc(hidden)]
pub shard_level_metrics: std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl EnableEnhancedMonitoringInput {
/// <p>The name of the stream for which to enable enhanced monitoring.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>List of shard-level metrics to enable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" enables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn shard_level_metrics(&self) -> std::option::Option<&[crate::model::MetricsName]> {
self.shard_level_metrics.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>DisableEnhancedMonitoring</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DisableEnhancedMonitoringInput {
/// <p>The name of the Kinesis data stream for which to disable enhanced monitoring.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>List of shard-level metrics to disable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" disables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
#[doc(hidden)]
pub shard_level_metrics: std::option::Option<std::vec::Vec<crate::model::MetricsName>>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl DisableEnhancedMonitoringInput {
/// <p>The name of the Kinesis data stream for which to disable enhanced monitoring.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>List of shard-level metrics to disable.</p>
/// <p>The following are the valid shard-level metrics. The value "<code>ALL</code>" disables every metric.</p>
/// <ul>
/// <li> <p> <code>IncomingBytes</code> </p> </li>
/// <li> <p> <code>IncomingRecords</code> </p> </li>
/// <li> <p> <code>OutgoingBytes</code> </p> </li>
/// <li> <p> <code>OutgoingRecords</code> </p> </li>
/// <li> <p> <code>WriteProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>ReadProvisionedThroughputExceeded</code> </p> </li>
/// <li> <p> <code>IteratorAgeMilliseconds</code> </p> </li>
/// <li> <p> <code>ALL</code> </p> </li>
/// </ul>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html">Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch</a> in the <i>Amazon Kinesis Data Streams Developer Guide</i>.</p>
pub fn shard_level_metrics(&self) -> std::option::Option<&[crate::model::MetricsName]> {
self.shard_level_metrics.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeStreamSummaryInput {
/// <p>The name of the stream to describe.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl DescribeStreamSummaryInput {
/// <p>The name of the stream to describe.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
/// <p>The name that you gave to the consumer.</p>
#[doc(hidden)]
pub consumer_name: std::option::Option<std::string::String>,
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer.</p>
#[doc(hidden)]
pub consumer_arn: std::option::Option<std::string::String>,
}
impl DescribeStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
/// <p>The name that you gave to the consumer.</p>
pub fn consumer_name(&self) -> std::option::Option<&str> {
self.consumer_name.as_deref()
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer.</p>
pub fn consumer_arn(&self) -> std::option::Option<&str> {
self.consumer_arn.as_deref()
}
}
/// <p>Represents the input for <code>DescribeStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeStreamInput {
/// <p>The name of the stream to describe.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The maximum number of shards to return in a single call. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
#[doc(hidden)]
pub limit: std::option::Option<i32>,
/// <p>The shard ID of the shard to start with.</p>
/// <p>Specify this parameter to indicate that you want to describe the stream starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior for <code>DescribeStream</code> is to describe the stream starting with the first shard in the stream.</p>
#[doc(hidden)]
pub exclusive_start_shard_id: std::option::Option<std::string::String>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl DescribeStreamInput {
/// <p>The name of the stream to describe.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The maximum number of shards to return in a single call. The default value is 100. If you specify a value greater than 100, at most 100 results are returned.</p>
pub fn limit(&self) -> std::option::Option<i32> {
self.limit
}
/// <p>The shard ID of the shard to start with.</p>
/// <p>Specify this parameter to indicate that you want to describe the stream starting with the shard whose ID immediately follows <code>ExclusiveStartShardId</code>.</p>
/// <p>If you don't specify this parameter, the default behavior for <code>DescribeStream</code> is to describe the stream starting with the first shard in the stream.</p>
pub fn exclusive_start_shard_id(&self) -> std::option::Option<&str> {
self.exclusive_start_shard_id.as_deref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeLimitsInput {}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeregisterStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
/// <p>The name that you gave to the consumer.</p>
#[doc(hidden)]
pub consumer_name: std::option::Option<std::string::String>,
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer. If you don't know the ARN of the consumer that you want to deregister, you can use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are currently registered with a given data stream. The description of a consumer contains its ARN.</p>
#[doc(hidden)]
pub consumer_arn: std::option::Option<std::string::String>,
}
impl DeregisterStreamConsumerInput {
/// <p>The ARN of the Kinesis data stream that the consumer is registered with. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams">Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces</a>.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
/// <p>The name that you gave to the consumer.</p>
pub fn consumer_name(&self) -> std::option::Option<&str> {
self.consumer_name.as_deref()
}
/// <p>The ARN returned by Kinesis Data Streams when you registered the consumer. If you don't know the ARN of the consumer that you want to deregister, you can use the ListStreamConsumers operation to get a list of the descriptions of all the consumers that are currently registered with a given data stream. The description of a consumer contains its ARN.</p>
pub fn consumer_arn(&self) -> std::option::Option<&str> {
self.consumer_arn.as_deref()
}
}
/// <p>Represents the input for <code>DeleteStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteStreamInput {
/// <p>The name of the stream to delete.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>If this parameter is unset (<code>null</code>) or if you set it to <code>false</code>, and the stream has registered consumers, the call to <code>DeleteStream</code> fails with a <code>ResourceInUseException</code>. </p>
#[doc(hidden)]
pub enforce_consumer_deletion: std::option::Option<bool>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl DeleteStreamInput {
/// <p>The name of the stream to delete.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>If this parameter is unset (<code>null</code>) or if you set it to <code>false</code>, and the stream has registered consumers, the call to <code>DeleteStream</code> fails with a <code>ResourceInUseException</code>. </p>
pub fn enforce_consumer_deletion(&self) -> std::option::Option<bool> {
self.enforce_consumer_deletion
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>DecreaseStreamRetentionPeriod</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DecreaseStreamRetentionPeriodInput {
/// <p>The name of the stream to modify.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The new retention period of the stream, in hours. Must be less than the current retention period.</p>
#[doc(hidden)]
pub retention_period_hours: std::option::Option<i32>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl DecreaseStreamRetentionPeriodInput {
/// <p>The name of the stream to modify.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The new retention period of the stream, in hours. Must be less than the current retention period.</p>
pub fn retention_period_hours(&self) -> std::option::Option<i32> {
self.retention_period_hours
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}
/// <p>Represents the input for <code>CreateStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateStreamInput {
/// <p>A name to identify the stream. The stream name is scoped to the Amazon Web Services account used by the application that creates the stream. It is also scoped by Amazon Web Services Region. That is, two streams in two different Amazon Web Services accounts can have the same name. Two streams in the same Amazon Web Services account but in two different Regions can also have the same name.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>The number of shards that the stream will use. The throughput of the stream is a function of the number of shards; more shards are required for greater provisioned throughput.</p>
#[doc(hidden)]
pub shard_count: std::option::Option<i32>,
/// <p> Indicates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams.</p>
#[doc(hidden)]
pub stream_mode_details: std::option::Option<crate::model::StreamModeDetails>,
}
impl CreateStreamInput {
/// <p>A name to identify the stream. The stream name is scoped to the Amazon Web Services account used by the application that creates the stream. It is also scoped by Amazon Web Services Region. That is, two streams in two different Amazon Web Services accounts can have the same name. Two streams in the same Amazon Web Services account but in two different Regions can also have the same name.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>The number of shards that the stream will use. The throughput of the stream is a function of the number of shards; more shards are required for greater provisioned throughput.</p>
pub fn shard_count(&self) -> std::option::Option<i32> {
self.shard_count
}
/// <p> Indicates the capacity mode of the data stream. Currently, in Kinesis Data Streams, you can choose between an <b>on-demand</b> capacity mode and a <b>provisioned</b> capacity mode for your data streams.</p>
pub fn stream_mode_details(&self) -> std::option::Option<&crate::model::StreamModeDetails> {
self.stream_mode_details.as_ref()
}
}
/// <p>Represents the input for <code>AddTagsToStream</code>.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AddTagsToStreamInput {
/// <p>The name of the stream.</p>
#[doc(hidden)]
pub stream_name: std::option::Option<std::string::String>,
/// <p>A set of up to 10 key-value pairs to use to create the tags.</p>
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
/// <p>The ARN of the stream.</p>
#[doc(hidden)]
pub stream_arn: std::option::Option<std::string::String>,
}
impl AddTagsToStreamInput {
/// <p>The name of the stream.</p>
pub fn stream_name(&self) -> std::option::Option<&str> {
self.stream_name.as_deref()
}
/// <p>A set of up to 10 key-value pairs to use to create the tags.</p>
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
/// <p>The ARN of the stream.</p>
pub fn stream_arn(&self) -> std::option::Option<&str> {
self.stream_arn.as_deref()
}
}