// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
use std::fmt::Write;
/// See [`CreateAccessInput`](crate::input::CreateAccessInput).
pub mod create_access_input {
/// A builder for [`CreateAccessInput`](crate::input::CreateAccessInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) home_directory: std::option::Option<std::string::String>,
pub(crate) home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
pub(crate) home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
pub(crate) policy: std::option::Option<std::string::String>,
pub(crate) posix_profile: std::option::Option<crate::model::PosixProfile>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) external_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.home_directory = Some(input.into());
self
}
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn set_home_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.home_directory = input;
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(mut self, input: crate::model::HomeDirectoryType) -> Self {
self.home_directory_type = Some(input);
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn set_home_directory_type(
mut self,
input: std::option::Option<crate::model::HomeDirectoryType>,
) -> Self {
self.home_directory_type = input;
self
}
/// Appends an item to `home_directory_mappings`.
///
/// To override the contents of this collection use [`set_home_directory_mappings`](Self::set_home_directory_mappings).
///
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
mut self,
input: crate::model::HomeDirectoryMapEntry,
) -> Self {
let mut v = self.home_directory_mappings.unwrap_or_default();
v.push(input);
self.home_directory_mappings = Some(v);
self
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn set_home_directory_mappings(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
) -> Self {
self.home_directory_mappings = input;
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(mut self, input: impl Into<std::string::String>) -> Self {
self.policy = Some(input.into());
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Security Token Service API Reference</i>.</p>
/// </note>
pub fn set_policy(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy = input;
self
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(mut self, input: crate::model::PosixProfile) -> Self {
self.posix_profile = Some(input);
self
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn set_posix_profile(
mut self,
input: std::option::Option<crate::model::PosixProfile>,
) -> Self {
self.posix_profile = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(mut self, input: impl Into<std::string::String>) -> Self {
self.external_id = Some(input.into());
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn set_external_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.external_id = input;
self
}
/// Consumes the builder and constructs a [`CreateAccessInput`](crate::input::CreateAccessInput).
pub fn build(
self,
) -> Result<crate::input::CreateAccessInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateAccessInput {
home_directory: self.home_directory,
home_directory_type: self.home_directory_type,
home_directory_mappings: self.home_directory_mappings,
policy: self.policy,
posix_profile: self.posix_profile,
role: self.role,
server_id: self.server_id,
external_id: self.external_id,
})
}
}
}
impl CreateAccessInput {
/// Consumes the builder and constructs an Operation<[`CreateAccess`](crate::operation::CreateAccess)>
#[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::CreateAccess,
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::CreateAccessInput,
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::CreateAccessInput,
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"),
"TransferService.CreateAccess",
);
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_access(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateAccess::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateAccess",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateAccessInput`](crate::input::CreateAccessInput).
pub fn builder() -> crate::input::create_access_input::Builder {
crate::input::create_access_input::Builder::default()
}
}
/// See [`CreateAgreementInput`](crate::input::CreateAgreementInput).
pub mod create_agreement_input {
/// A builder for [`CreateAgreementInput`](crate::input::CreateAgreementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) local_profile_id: std::option::Option<std::string::String>,
pub(crate) partner_profile_id: std::option::Option<std::string::String>,
pub(crate) base_directory: std::option::Option<std::string::String>,
pub(crate) access_role: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<crate::model::AgreementStatusType>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>A name or short description to identify the agreement. </p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A name or short description to identify the agreement. </p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier for the AS2 local profile.</p>
pub fn local_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.local_profile_id = Some(input.into());
self
}
/// <p>A unique identifier for the AS2 local profile.</p>
pub fn set_local_profile_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.local_profile_id = input;
self
}
/// <p>A unique identifier for the partner profile used in the agreement.</p>
pub fn partner_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.partner_profile_id = Some(input.into());
self
}
/// <p>A unique identifier for the partner profile used in the agreement.</p>
pub fn set_partner_profile_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.partner_profile_id = input;
self
}
/// <p>The landing directory (folder) for files transferred by using the AS2 protocol.</p>
/// <p>A <code>BaseDirectory</code> example is <i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i>.</p>
pub fn base_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.base_directory = Some(input.into());
self
}
/// <p>The landing directory (folder) for files transferred by using the AS2 protocol.</p>
/// <p>A <code>BaseDirectory</code> example is <i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i>.</p>
pub fn set_base_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.base_directory = input;
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(mut self, input: impl Into<std::string::String>) -> Self {
self.access_role = Some(input.into());
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn set_access_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.access_role = input;
self
}
/// <p>The status of the agreement. The agreement can be either <code>ACTIVE</code> or <code>INACTIVE</code>.</p>
pub fn status(mut self, input: crate::model::AgreementStatusType) -> Self {
self.status = Some(input);
self
}
/// <p>The status of the agreement. The agreement can be either <code>ACTIVE</code> or <code>INACTIVE</code>.</p>
pub fn set_status(
mut self,
input: std::option::Option<crate::model::AgreementStatusType>,
) -> Self {
self.status = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for agreements.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for agreements.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateAgreementInput`](crate::input::CreateAgreementInput).
pub fn build(
self,
) -> Result<crate::input::CreateAgreementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateAgreementInput {
description: self.description,
server_id: self.server_id,
local_profile_id: self.local_profile_id,
partner_profile_id: self.partner_profile_id,
base_directory: self.base_directory,
access_role: self.access_role,
status: self.status,
tags: self.tags,
})
}
}
}
impl CreateAgreementInput {
/// Consumes the builder and constructs an Operation<[`CreateAgreement`](crate::operation::CreateAgreement)>
#[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::CreateAgreement,
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::CreateAgreementInput,
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::CreateAgreementInput,
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"),
"TransferService.CreateAgreement",
);
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_agreement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateAgreement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateAgreement",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateAgreementInput`](crate::input::CreateAgreementInput).
pub fn builder() -> crate::input::create_agreement_input::Builder {
crate::input::create_agreement_input::Builder::default()
}
}
/// See [`CreateConnectorInput`](crate::input::CreateConnectorInput).
pub mod create_connector_input {
/// A builder for [`CreateConnectorInput`](crate::input::CreateConnectorInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) url: std::option::Option<std::string::String>,
pub(crate) as2_config: std::option::Option<crate::model::As2ConnectorConfig>,
pub(crate) access_role: std::option::Option<std::string::String>,
pub(crate) logging_role: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn url(mut self, input: impl Into<std::string::String>) -> Self {
self.url = Some(input.into());
self
}
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn set_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.url = input;
self
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn as2_config(mut self, input: crate::model::As2ConnectorConfig) -> Self {
self.as2_config = Some(input);
self
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn set_as2_config(
mut self,
input: std::option::Option<crate::model::As2ConnectorConfig>,
) -> Self {
self.as2_config = input;
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(mut self, input: impl Into<std::string::String>) -> Self {
self.access_role = Some(input.into());
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn set_access_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.access_role = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn logging_role(mut self, input: impl Into<std::string::String>) -> Self {
self.logging_role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn set_logging_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.logging_role = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for connectors. Tags are metadata attached to connectors for any purpose.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for connectors. Tags are metadata attached to connectors for any purpose.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateConnectorInput`](crate::input::CreateConnectorInput).
pub fn build(
self,
) -> Result<crate::input::CreateConnectorInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateConnectorInput {
url: self.url,
as2_config: self.as2_config,
access_role: self.access_role,
logging_role: self.logging_role,
tags: self.tags,
})
}
}
}
impl CreateConnectorInput {
/// Consumes the builder and constructs an Operation<[`CreateConnector`](crate::operation::CreateConnector)>
#[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::CreateConnector,
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::CreateConnectorInput,
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::CreateConnectorInput,
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"),
"TransferService.CreateConnector",
);
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_connector(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateConnector::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateConnector",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateConnectorInput`](crate::input::CreateConnectorInput).
pub fn builder() -> crate::input::create_connector_input::Builder {
crate::input::create_connector_input::Builder::default()
}
}
/// See [`CreateProfileInput`](crate::input::CreateProfileInput).
pub mod create_profile_input {
/// A builder for [`CreateProfileInput`](crate::input::CreateProfileInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) as2_id: std::option::Option<std::string::String>,
pub(crate) profile_type: std::option::Option<crate::model::ProfileType>,
pub(crate) certificate_ids: std::option::Option<std::vec::Vec<std::string::String>>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The <code>As2Id</code> is the <i>AS2-name</i>, as defined in the <a href="https://datatracker.ietf.org/doc/html/rfc4130">RFC 4130</a>. For inbound transfers, this is the <code>AS2-From</code> header for the AS2 messages sent from the partner. For outbound connectors, this is the <code>AS2-To</code> header for the AS2 messages sent to the partner using the <code>StartFileTransfer</code> API operation. This ID cannot include spaces.</p>
pub fn as2_id(mut self, input: impl Into<std::string::String>) -> Self {
self.as2_id = Some(input.into());
self
}
/// <p>The <code>As2Id</code> is the <i>AS2-name</i>, as defined in the <a href="https://datatracker.ietf.org/doc/html/rfc4130">RFC 4130</a>. For inbound transfers, this is the <code>AS2-From</code> header for the AS2 messages sent from the partner. For outbound connectors, this is the <code>AS2-To</code> header for the AS2 messages sent to the partner using the <code>StartFileTransfer</code> API operation. This ID cannot include spaces.</p>
pub fn set_as2_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.as2_id = input;
self
}
/// <p>Determines the type of profile to create:</p>
/// <ul>
/// <li> <p>Specify <code>LOCAL</code> to create a local profile. A local profile represents the AS2-enabled Transfer Family server organization or party.</p> </li>
/// <li> <p>Specify <code>PARTNER</code> to create a partner profile. A partner profile represents a remote organization, external to Transfer Family.</p> </li>
/// </ul>
pub fn profile_type(mut self, input: crate::model::ProfileType) -> Self {
self.profile_type = Some(input);
self
}
/// <p>Determines the type of profile to create:</p>
/// <ul>
/// <li> <p>Specify <code>LOCAL</code> to create a local profile. A local profile represents the AS2-enabled Transfer Family server organization or party.</p> </li>
/// <li> <p>Specify <code>PARTNER</code> to create a partner profile. A partner profile represents a remote organization, external to Transfer Family.</p> </li>
/// </ul>
pub fn set_profile_type(
mut self,
input: std::option::Option<crate::model::ProfileType>,
) -> Self {
self.profile_type = input;
self
}
/// Appends an item to `certificate_ids`.
///
/// To override the contents of this collection use [`set_certificate_ids`](Self::set_certificate_ids).
///
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.certificate_ids.unwrap_or_default();
v.push(input.into());
self.certificate_ids = Some(v);
self
}
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn set_certificate_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.certificate_ids = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for AS2 profiles.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for AS2 profiles.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateProfileInput`](crate::input::CreateProfileInput).
pub fn build(
self,
) -> Result<crate::input::CreateProfileInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateProfileInput {
as2_id: self.as2_id,
profile_type: self.profile_type,
certificate_ids: self.certificate_ids,
tags: self.tags,
})
}
}
}
impl CreateProfileInput {
/// Consumes the builder and constructs an Operation<[`CreateProfile`](crate::operation::CreateProfile)>
#[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::CreateProfile,
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::CreateProfileInput,
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::CreateProfileInput,
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"),
"TransferService.CreateProfile",
);
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_profile(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateProfile",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateProfileInput`](crate::input::CreateProfileInput).
pub fn builder() -> crate::input::create_profile_input::Builder {
crate::input::create_profile_input::Builder::default()
}
}
/// See [`CreateServerInput`](crate::input::CreateServerInput).
pub mod create_server_input {
/// A builder for [`CreateServerInput`](crate::input::CreateServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) certificate: std::option::Option<std::string::String>,
pub(crate) domain: std::option::Option<crate::model::Domain>,
pub(crate) endpoint_details: std::option::Option<crate::model::EndpointDetails>,
pub(crate) endpoint_type: std::option::Option<crate::model::EndpointType>,
pub(crate) host_key: std::option::Option<std::string::String>,
pub(crate) identity_provider_details:
std::option::Option<crate::model::IdentityProviderDetails>,
pub(crate) identity_provider_type: std::option::Option<crate::model::IdentityProviderType>,
pub(crate) logging_role: std::option::Option<std::string::String>,
pub(crate) post_authentication_login_banner: std::option::Option<std::string::String>,
pub(crate) pre_authentication_login_banner: std::option::Option<std::string::String>,
pub(crate) protocols: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
pub(crate) protocol_details: std::option::Option<crate::model::ProtocolDetails>,
pub(crate) security_policy_name: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub(crate) workflow_details: std::option::Option<crate::model::WorkflowDetails>,
}
impl Builder {
/// <p>The Amazon Resource Name (ARN) of the Certificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn certificate(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Certificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn set_certificate(mut self, input: std::option::Option<std::string::String>) -> Self {
self.certificate = input;
self
}
/// <p>The domain of the storage system that is used for file transfers. There are two domains available: Amazon Simple Storage Service (Amazon S3) and Amazon Elastic File System (Amazon EFS). The default value is S3.</p> <note>
/// <p>After the server is created, the domain cannot be changed.</p>
/// </note>
pub fn domain(mut self, input: crate::model::Domain) -> Self {
self.domain = Some(input);
self
}
/// <p>The domain of the storage system that is used for file transfers. There are two domains available: Amazon Simple Storage Service (Amazon S3) and Amazon Elastic File System (Amazon EFS). The default value is S3.</p> <note>
/// <p>After the server is created, the domain cannot be changed.</p>
/// </note>
pub fn set_domain(mut self, input: std::option::Option<crate::model::Domain>) -> Self {
self.domain = input;
self
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn endpoint_details(mut self, input: crate::model::EndpointDetails) -> Self {
self.endpoint_details = Some(input);
self
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn set_endpoint_details(
mut self,
input: std::option::Option<crate::model::EndpointDetails>,
) -> Self {
self.endpoint_details = input;
self
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn endpoint_type(mut self, input: crate::model::EndpointType) -> Self {
self.endpoint_type = Some(input);
self
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn set_endpoint_type(
mut self,
input: std::option::Option<crate::model::EndpointType>,
) -> Self {
self.endpoint_type = input;
self
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn host_key(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key = Some(input.into());
self
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn set_host_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_key = input;
self
}
/// <p>Required when <code>IdentityProviderType</code> is set to <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>. Accepts an array containing all of the information required to use a directory in <code>AWS_DIRECTORY_SERVICE</code> or invoke a customer-supplied authentication API, including the API Gateway URL. Not required when <code>IdentityProviderType</code> is set to <code>SERVICE_MANAGED</code>.</p>
pub fn identity_provider_details(
mut self,
input: crate::model::IdentityProviderDetails,
) -> Self {
self.identity_provider_details = Some(input);
self
}
/// <p>Required when <code>IdentityProviderType</code> is set to <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>. Accepts an array containing all of the information required to use a directory in <code>AWS_DIRECTORY_SERVICE</code> or invoke a customer-supplied authentication API, including the API Gateway URL. Not required when <code>IdentityProviderType</code> is set to <code>SERVICE_MANAGED</code>.</p>
pub fn set_identity_provider_details(
mut self,
input: std::option::Option<crate::model::IdentityProviderDetails>,
) -> Self {
self.identity_provider_details = input;
self
}
/// <p>The mode of authentication for a server. The default value is <code>SERVICE_MANAGED</code>, which allows you to store and access user credentials within the Transfer Family service.</p>
/// <p>Use <code>AWS_DIRECTORY_SERVICE</code> to provide access to Active Directory groups in Directory Service for Microsoft Active Directory or Microsoft Active Directory in your on-premises environment or in Amazon Web Services using AD Connector. This option also requires you to provide a Directory ID by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>API_GATEWAY</code> value to integrate with an identity provider of your choosing. The <code>API_GATEWAY</code> setting requires you to provide an Amazon API Gateway endpoint URL to call for authentication by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>AWS_LAMBDA</code> value to directly use an Lambda function as your identity provider. If you choose this value, you must specify the ARN for the Lambda function in the <code>Function</code> parameter or the <code>IdentityProviderDetails</code> data type.</p>
pub fn identity_provider_type(mut self, input: crate::model::IdentityProviderType) -> Self {
self.identity_provider_type = Some(input);
self
}
/// <p>The mode of authentication for a server. The default value is <code>SERVICE_MANAGED</code>, which allows you to store and access user credentials within the Transfer Family service.</p>
/// <p>Use <code>AWS_DIRECTORY_SERVICE</code> to provide access to Active Directory groups in Directory Service for Microsoft Active Directory or Microsoft Active Directory in your on-premises environment or in Amazon Web Services using AD Connector. This option also requires you to provide a Directory ID by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>API_GATEWAY</code> value to integrate with an identity provider of your choosing. The <code>API_GATEWAY</code> setting requires you to provide an Amazon API Gateway endpoint URL to call for authentication by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>AWS_LAMBDA</code> value to directly use an Lambda function as your identity provider. If you choose this value, you must specify the ARN for the Lambda function in the <code>Function</code> parameter or the <code>IdentityProviderDetails</code> data type.</p>
pub fn set_identity_provider_type(
mut self,
input: std::option::Option<crate::model::IdentityProviderType>,
) -> Self {
self.identity_provider_type = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn logging_role(mut self, input: impl Into<std::string::String>) -> Self {
self.logging_role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn set_logging_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.logging_role = input;
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn post_authentication_login_banner(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.post_authentication_login_banner = Some(input.into());
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn set_post_authentication_login_banner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.post_authentication_login_banner = input;
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn pre_authentication_login_banner(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.pre_authentication_login_banner = Some(input.into());
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn set_pre_authentication_login_banner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pre_authentication_login_banner = input;
self
}
/// Appends an item to `protocols`.
///
/// To override the contents of this collection use [`set_protocols`](Self::set_protocols).
///
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn protocols(mut self, input: crate::model::Protocol) -> Self {
let mut v = self.protocols.unwrap_or_default();
v.push(input);
self.protocols = Some(v);
self
}
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn set_protocols(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
) -> Self {
self.protocols = input;
self
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn protocol_details(mut self, input: crate::model::ProtocolDetails) -> Self {
self.protocol_details = Some(input);
self
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn set_protocol_details(
mut self,
input: std::option::Option<crate::model::ProtocolDetails>,
) -> Self {
self.protocol_details = input;
self
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(mut self, input: impl Into<std::string::String>) -> Self {
self.security_policy_name = Some(input.into());
self
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn set_security_policy_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_policy_name = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for servers.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for servers.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
pub fn workflow_details(mut self, input: crate::model::WorkflowDetails) -> Self {
self.workflow_details = Some(input);
self
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
pub fn set_workflow_details(
mut self,
input: std::option::Option<crate::model::WorkflowDetails>,
) -> Self {
self.workflow_details = input;
self
}
/// Consumes the builder and constructs a [`CreateServerInput`](crate::input::CreateServerInput).
pub fn build(
self,
) -> Result<crate::input::CreateServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateServerInput {
certificate: self.certificate,
domain: self.domain,
endpoint_details: self.endpoint_details,
endpoint_type: self.endpoint_type,
host_key: self.host_key,
identity_provider_details: self.identity_provider_details,
identity_provider_type: self.identity_provider_type,
logging_role: self.logging_role,
post_authentication_login_banner: self.post_authentication_login_banner,
pre_authentication_login_banner: self.pre_authentication_login_banner,
protocols: self.protocols,
protocol_details: self.protocol_details,
security_policy_name: self.security_policy_name,
tags: self.tags,
workflow_details: self.workflow_details,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("certificate", &self.certificate);
formatter.field("domain", &self.domain);
formatter.field("endpoint_details", &self.endpoint_details);
formatter.field("endpoint_type", &self.endpoint_type);
formatter.field("host_key", &"*** Sensitive Data Redacted ***");
formatter.field("identity_provider_details", &self.identity_provider_details);
formatter.field("identity_provider_type", &self.identity_provider_type);
formatter.field("logging_role", &self.logging_role);
formatter.field(
"post_authentication_login_banner",
&self.post_authentication_login_banner,
);
formatter.field(
"pre_authentication_login_banner",
&self.pre_authentication_login_banner,
);
formatter.field("protocols", &self.protocols);
formatter.field("protocol_details", &self.protocol_details);
formatter.field("security_policy_name", &self.security_policy_name);
formatter.field("tags", &self.tags);
formatter.field("workflow_details", &self.workflow_details);
formatter.finish()
}
}
}
impl CreateServerInput {
/// Consumes the builder and constructs an Operation<[`CreateServer`](crate::operation::CreateServer)>
#[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::CreateServer,
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::CreateServerInput,
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::CreateServerInput,
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"),
"TransferService.CreateServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateServerInput`](crate::input::CreateServerInput).
pub fn builder() -> crate::input::create_server_input::Builder {
crate::input::create_server_input::Builder::default()
}
}
/// See [`CreateUserInput`](crate::input::CreateUserInput).
pub mod create_user_input {
/// A builder for [`CreateUserInput`](crate::input::CreateUserInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) home_directory: std::option::Option<std::string::String>,
pub(crate) home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
pub(crate) home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
pub(crate) policy: std::option::Option<std::string::String>,
pub(crate) posix_profile: std::option::Option<crate::model::PosixProfile>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) ssh_public_key_body: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.home_directory = Some(input.into());
self
}
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn set_home_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.home_directory = input;
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(mut self, input: crate::model::HomeDirectoryType) -> Self {
self.home_directory_type = Some(input);
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn set_home_directory_type(
mut self,
input: std::option::Option<crate::model::HomeDirectoryType>,
) -> Self {
self.home_directory_type = input;
self
}
/// Appends an item to `home_directory_mappings`.
///
/// To override the contents of this collection use [`set_home_directory_mappings`](Self::set_home_directory_mappings).
///
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock your user down to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
mut self,
input: crate::model::HomeDirectoryMapEntry,
) -> Self {
let mut v = self.home_directory_mappings.unwrap_or_default();
v.push(input);
self.home_directory_mappings = Some(v);
self
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock your user down to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn set_home_directory_mappings(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
) -> Self {
self.home_directory_mappings = input;
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(mut self, input: impl Into<std::string::String>) -> Self {
self.policy = Some(input.into());
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn set_policy(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy = input;
self
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in Amazon EFS determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(mut self, input: crate::model::PosixProfile) -> Self {
self.posix_profile = Some(input);
self
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in Amazon EFS determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn set_posix_profile(
mut self,
input: std::option::Option<crate::model::PosixProfile>,
) -> Self {
self.posix_profile = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The public portion of the Secure Shell (SSH) key used to authenticate the user to the server.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn ssh_public_key_body(mut self, input: impl Into<std::string::String>) -> Self {
self.ssh_public_key_body = Some(input.into());
self
}
/// <p>The public portion of the Secure Shell (SSH) key used to authenticate the user to the server.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn set_ssh_public_key_body(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.ssh_public_key_body = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for users. Tags are metadata attached to users for any purpose.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for users. Tags are metadata attached to users for any purpose.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// <p>A unique string that identifies a user and is associated with a <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>A unique string that identifies a user and is associated with a <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`CreateUserInput`](crate::input::CreateUserInput).
pub fn build(
self,
) -> Result<crate::input::CreateUserInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateUserInput {
home_directory: self.home_directory,
home_directory_type: self.home_directory_type,
home_directory_mappings: self.home_directory_mappings,
policy: self.policy,
posix_profile: self.posix_profile,
role: self.role,
server_id: self.server_id,
ssh_public_key_body: self.ssh_public_key_body,
tags: self.tags,
user_name: self.user_name,
})
}
}
}
impl CreateUserInput {
/// Consumes the builder and constructs an Operation<[`CreateUser`](crate::operation::CreateUser)>
#[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::CreateUser,
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::CreateUserInput,
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::CreateUserInput,
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"),
"TransferService.CreateUser",
);
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_user(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateUser",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateUserInput`](crate::input::CreateUserInput).
pub fn builder() -> crate::input::create_user_input::Builder {
crate::input::create_user_input::Builder::default()
}
}
/// See [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub mod create_workflow_input {
/// A builder for [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) steps: std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
pub(crate) on_exception_steps:
std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>A textual description for the workflow.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A textual description for the workflow.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Appends an item to `steps`.
///
/// To override the contents of this collection use [`set_steps`](Self::set_steps).
///
/// <p>Specifies the details for the steps that are in the specified workflow.</p>
/// <p> The <code>TYPE</code> specifies which of the following actions is being taken for this step. </p>
/// <ul>
/// <li> <p> <i>COPY</i>: Copy the file to another location.</p> </li>
/// <li> <p> <i>CUSTOM</i>: Perform a custom step with an Lambda function target.</p> </li>
/// <li> <p> <i>DELETE</i>: Delete the file.</p> </li>
/// <li> <p> <i>TAG</i>: Add a tag to the file.</p> </li>
/// </ul> <note>
/// <p> Currently, copying and tagging are supported only on S3. </p>
/// </note>
/// <p> For file location, you specify either the S3 bucket and key, or the EFS file system ID and path. </p>
pub fn steps(mut self, input: crate::model::WorkflowStep) -> Self {
let mut v = self.steps.unwrap_or_default();
v.push(input);
self.steps = Some(v);
self
}
/// <p>Specifies the details for the steps that are in the specified workflow.</p>
/// <p> The <code>TYPE</code> specifies which of the following actions is being taken for this step. </p>
/// <ul>
/// <li> <p> <i>COPY</i>: Copy the file to another location.</p> </li>
/// <li> <p> <i>CUSTOM</i>: Perform a custom step with an Lambda function target.</p> </li>
/// <li> <p> <i>DELETE</i>: Delete the file.</p> </li>
/// <li> <p> <i>TAG</i>: Add a tag to the file.</p> </li>
/// </ul> <note>
/// <p> Currently, copying and tagging are supported only on S3. </p>
/// </note>
/// <p> For file location, you specify either the S3 bucket and key, or the EFS file system ID and path. </p>
pub fn set_steps(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
) -> Self {
self.steps = input;
self
}
/// Appends an item to `on_exception_steps`.
///
/// To override the contents of this collection use [`set_on_exception_steps`](Self::set_on_exception_steps).
///
/// <p>Specifies the steps (actions) to take if errors are encountered during execution of the workflow.</p> <note>
/// <p>For custom steps, the lambda function needs to send <code>FAILURE</code> to the call back API to kick off the exception steps. Additionally, if the lambda does not send <code>SUCCESS</code> before it times out, the exception steps are executed.</p>
/// </note>
pub fn on_exception_steps(mut self, input: crate::model::WorkflowStep) -> Self {
let mut v = self.on_exception_steps.unwrap_or_default();
v.push(input);
self.on_exception_steps = Some(v);
self
}
/// <p>Specifies the steps (actions) to take if errors are encountered during execution of the workflow.</p> <note>
/// <p>For custom steps, the lambda function needs to send <code>FAILURE</code> to the call back API to kick off the exception steps. Additionally, if the lambda does not send <code>SUCCESS</code> before it times out, the exception steps are executed.</p>
/// </note>
pub fn set_on_exception_steps(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
) -> Self {
self.on_exception_steps = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for workflows. Tags are metadata attached to workflows for any purpose.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for workflows. Tags are metadata attached to workflows for any purpose.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::CreateWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::CreateWorkflowInput {
description: self.description,
steps: self.steps,
on_exception_steps: self.on_exception_steps,
tags: self.tags,
})
}
}
}
impl CreateWorkflowInput {
/// Consumes the builder and constructs an Operation<[`CreateWorkflow`](crate::operation::CreateWorkflow)>
#[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::CreateWorkflow,
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::CreateWorkflowInput,
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::CreateWorkflowInput,
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"),
"TransferService.CreateWorkflow",
);
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_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::CreateWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"CreateWorkflow",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`CreateWorkflowInput`](crate::input::CreateWorkflowInput).
pub fn builder() -> crate::input::create_workflow_input::Builder {
crate::input::create_workflow_input::Builder::default()
}
}
/// See [`DeleteAccessInput`](crate::input::DeleteAccessInput).
pub mod delete_access_input {
/// A builder for [`DeleteAccessInput`](crate::input::DeleteAccessInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) external_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(mut self, input: impl Into<std::string::String>) -> Self {
self.external_id = Some(input.into());
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn set_external_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.external_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteAccessInput`](crate::input::DeleteAccessInput).
pub fn build(
self,
) -> Result<crate::input::DeleteAccessInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteAccessInput {
server_id: self.server_id,
external_id: self.external_id,
})
}
}
}
impl DeleteAccessInput {
/// Consumes the builder and constructs an Operation<[`DeleteAccess`](crate::operation::DeleteAccess)>
#[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::DeleteAccess,
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::DeleteAccessInput,
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::DeleteAccessInput,
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"),
"TransferService.DeleteAccess",
);
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_access(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteAccess::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteAccess",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteAccessInput`](crate::input::DeleteAccessInput).
pub fn builder() -> crate::input::delete_access_input::Builder {
crate::input::delete_access_input::Builder::default()
}
}
/// See [`DeleteAgreementInput`](crate::input::DeleteAgreementInput).
pub mod delete_agreement_input {
/// A builder for [`DeleteAgreementInput`](crate::input::DeleteAgreementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) agreement_id: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(mut self, input: impl Into<std::string::String>) -> Self {
self.agreement_id = Some(input.into());
self
}
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn set_agreement_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.agreement_id = input;
self
}
/// <p>The server identifier associated with the agreement that you are deleting.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The server identifier associated with the agreement that you are deleting.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteAgreementInput`](crate::input::DeleteAgreementInput).
pub fn build(
self,
) -> Result<crate::input::DeleteAgreementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteAgreementInput {
agreement_id: self.agreement_id,
server_id: self.server_id,
})
}
}
}
impl DeleteAgreementInput {
/// Consumes the builder and constructs an Operation<[`DeleteAgreement`](crate::operation::DeleteAgreement)>
#[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::DeleteAgreement,
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::DeleteAgreementInput,
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::DeleteAgreementInput,
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"),
"TransferService.DeleteAgreement",
);
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_agreement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteAgreement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteAgreement",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteAgreementInput`](crate::input::DeleteAgreementInput).
pub fn builder() -> crate::input::delete_agreement_input::Builder {
crate::input::delete_agreement_input::Builder::default()
}
}
/// See [`DeleteCertificateInput`](crate::input::DeleteCertificateInput).
pub mod delete_certificate_input {
/// A builder for [`DeleteCertificateInput`](crate::input::DeleteCertificateInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) certificate_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the certificate object that you are deleting.</p>
pub fn certificate_id(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_id = Some(input.into());
self
}
/// <p>The identifier of the certificate object that you are deleting.</p>
pub fn set_certificate_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteCertificateInput`](crate::input::DeleteCertificateInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteCertificateInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteCertificateInput {
certificate_id: self.certificate_id,
})
}
}
}
impl DeleteCertificateInput {
/// Consumes the builder and constructs an Operation<[`DeleteCertificate`](crate::operation::DeleteCertificate)>
#[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::DeleteCertificate,
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::DeleteCertificateInput,
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::DeleteCertificateInput,
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"),
"TransferService.DeleteCertificate",
);
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_certificate(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteCertificate::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteCertificate",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteCertificateInput`](crate::input::DeleteCertificateInput).
pub fn builder() -> crate::input::delete_certificate_input::Builder {
crate::input::delete_certificate_input::Builder::default()
}
}
/// See [`DeleteConnectorInput`](crate::input::DeleteConnectorInput).
pub mod delete_connector_input {
/// A builder for [`DeleteConnectorInput`](crate::input::DeleteConnectorInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(mut self, input: impl Into<std::string::String>) -> Self {
self.connector_id = Some(input.into());
self
}
/// <p>The unique identifier for the connector.</p>
pub fn set_connector_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.connector_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteConnectorInput`](crate::input::DeleteConnectorInput).
pub fn build(
self,
) -> Result<crate::input::DeleteConnectorInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteConnectorInput {
connector_id: self.connector_id,
})
}
}
}
impl DeleteConnectorInput {
/// Consumes the builder and constructs an Operation<[`DeleteConnector`](crate::operation::DeleteConnector)>
#[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::DeleteConnector,
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::DeleteConnectorInput,
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::DeleteConnectorInput,
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"),
"TransferService.DeleteConnector",
);
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_connector(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteConnector::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteConnector",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteConnectorInput`](crate::input::DeleteConnectorInput).
pub fn builder() -> crate::input::delete_connector_input::Builder {
crate::input::delete_connector_input::Builder::default()
}
}
/// See [`DeleteHostKeyInput`](crate::input::DeleteHostKeyInput).
pub mod delete_host_key_input {
/// A builder for [`DeleteHostKeyInput`](crate::input::DeleteHostKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) host_key_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the server that contains the host key that you are deleting.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server that contains the host key that you are deleting.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The identifier of the host key that you are deleting.</p>
pub fn host_key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key_id = Some(input.into());
self
}
/// <p>The identifier of the host key that you are deleting.</p>
pub fn set_host_key_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_key_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteHostKeyInput`](crate::input::DeleteHostKeyInput).
pub fn build(
self,
) -> Result<crate::input::DeleteHostKeyInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteHostKeyInput {
server_id: self.server_id,
host_key_id: self.host_key_id,
})
}
}
}
impl DeleteHostKeyInput {
/// Consumes the builder and constructs an Operation<[`DeleteHostKey`](crate::operation::DeleteHostKey)>
#[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::DeleteHostKey,
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::DeleteHostKeyInput,
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::DeleteHostKeyInput,
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"),
"TransferService.DeleteHostKey",
);
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_host_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteHostKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteHostKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteHostKeyInput`](crate::input::DeleteHostKeyInput).
pub fn builder() -> crate::input::delete_host_key_input::Builder {
crate::input::delete_host_key_input::Builder::default()
}
}
/// See [`DeleteProfileInput`](crate::input::DeleteProfileInput).
pub mod delete_profile_input {
/// A builder for [`DeleteProfileInput`](crate::input::DeleteProfileInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the profile that you are deleting.</p>
pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_id = Some(input.into());
self
}
/// <p>The identifier of the profile that you are deleting.</p>
pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteProfileInput`](crate::input::DeleteProfileInput).
pub fn build(
self,
) -> Result<crate::input::DeleteProfileInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteProfileInput {
profile_id: self.profile_id,
})
}
}
}
impl DeleteProfileInput {
/// Consumes the builder and constructs an Operation<[`DeleteProfile`](crate::operation::DeleteProfile)>
#[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::DeleteProfile,
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::DeleteProfileInput,
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::DeleteProfileInput,
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"),
"TransferService.DeleteProfile",
);
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_profile(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteProfile",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteProfileInput`](crate::input::DeleteProfileInput).
pub fn builder() -> crate::input::delete_profile_input::Builder {
crate::input::delete_profile_input::Builder::default()
}
}
/// See [`DeleteServerInput`](crate::input::DeleteServerInput).
pub mod delete_server_input {
/// A builder for [`DeleteServerInput`](crate::input::DeleteServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique system-assigned identifier for a server instance.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A unique system-assigned identifier for a server instance.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteServerInput`](crate::input::DeleteServerInput).
pub fn build(
self,
) -> Result<crate::input::DeleteServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteServerInput {
server_id: self.server_id,
})
}
}
}
impl DeleteServerInput {
/// Consumes the builder and constructs an Operation<[`DeleteServer`](crate::operation::DeleteServer)>
#[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::DeleteServer,
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::DeleteServerInput,
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::DeleteServerInput,
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"),
"TransferService.DeleteServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteServerInput`](crate::input::DeleteServerInput).
pub fn builder() -> crate::input::delete_server_input::Builder {
crate::input::delete_server_input::Builder::default()
}
}
/// See [`DeleteSshPublicKeyInput`](crate::input::DeleteSshPublicKeyInput).
pub mod delete_ssh_public_key_input {
/// A builder for [`DeleteSshPublicKeyInput`](crate::input::DeleteSshPublicKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) ssh_public_key_id: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a file transfer protocol-enabled server instance that has the user assigned to it.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a file transfer protocol-enabled server instance that has the user assigned to it.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier used to reference your user's specific SSH key.</p>
pub fn ssh_public_key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.ssh_public_key_id = Some(input.into());
self
}
/// <p>A unique identifier used to reference your user's specific SSH key.</p>
pub fn set_ssh_public_key_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.ssh_public_key_id = input;
self
}
/// <p>A unique string that identifies a user whose public key is being deleted.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>A unique string that identifies a user whose public key is being deleted.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteSshPublicKeyInput`](crate::input::DeleteSshPublicKeyInput).
pub fn build(
self,
) -> Result<
crate::input::DeleteSshPublicKeyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DeleteSshPublicKeyInput {
server_id: self.server_id,
ssh_public_key_id: self.ssh_public_key_id,
user_name: self.user_name,
})
}
}
}
impl DeleteSshPublicKeyInput {
/// Consumes the builder and constructs an Operation<[`DeleteSshPublicKey`](crate::operation::DeleteSshPublicKey)>
#[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::DeleteSshPublicKey,
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::DeleteSshPublicKeyInput,
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::DeleteSshPublicKeyInput,
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"),
"TransferService.DeleteSshPublicKey",
);
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_ssh_public_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteSshPublicKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteSshPublicKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteSshPublicKeyInput`](crate::input::DeleteSshPublicKeyInput).
pub fn builder() -> crate::input::delete_ssh_public_key_input::Builder {
crate::input::delete_ssh_public_key_input::Builder::default()
}
}
/// See [`DeleteUserInput`](crate::input::DeleteUserInput).
pub mod delete_user_input {
/// A builder for [`DeleteUserInput`](crate::input::DeleteUserInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server instance that has the user assigned to it.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance that has the user assigned to it.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique string that identifies a user that is being deleted from a server.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>A unique string that identifies a user that is being deleted from a server.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`DeleteUserInput`](crate::input::DeleteUserInput).
pub fn build(
self,
) -> Result<crate::input::DeleteUserInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteUserInput {
server_id: self.server_id,
user_name: self.user_name,
})
}
}
}
impl DeleteUserInput {
/// Consumes the builder and constructs an Operation<[`DeleteUser`](crate::operation::DeleteUser)>
#[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::DeleteUser,
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::DeleteUserInput,
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::DeleteUserInput,
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"),
"TransferService.DeleteUser",
);
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_user(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteUser",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteUserInput`](crate::input::DeleteUserInput).
pub fn builder() -> crate::input::delete_user_input::Builder {
crate::input::delete_user_input::Builder::default()
}
}
/// See [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub mod delete_workflow_input {
/// A builder for [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) workflow_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_id = Some(input.into());
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn set_workflow_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.workflow_id = input;
self
}
/// Consumes the builder and constructs a [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub fn build(
self,
) -> Result<crate::input::DeleteWorkflowInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DeleteWorkflowInput {
workflow_id: self.workflow_id,
})
}
}
}
impl DeleteWorkflowInput {
/// Consumes the builder and constructs an Operation<[`DeleteWorkflow`](crate::operation::DeleteWorkflow)>
#[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::DeleteWorkflow,
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::DeleteWorkflowInput,
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::DeleteWorkflowInput,
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"),
"TransferService.DeleteWorkflow",
);
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_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DeleteWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DeleteWorkflow",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DeleteWorkflowInput`](crate::input::DeleteWorkflowInput).
pub fn builder() -> crate::input::delete_workflow_input::Builder {
crate::input::delete_workflow_input::Builder::default()
}
}
/// See [`DescribeAccessInput`](crate::input::DescribeAccessInput).
pub mod describe_access_input {
/// A builder for [`DescribeAccessInput`](crate::input::DescribeAccessInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) external_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server that has this access assigned.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that has this access assigned.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(mut self, input: impl Into<std::string::String>) -> Self {
self.external_id = Some(input.into());
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn set_external_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.external_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeAccessInput`](crate::input::DescribeAccessInput).
pub fn build(
self,
) -> Result<crate::input::DescribeAccessInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeAccessInput {
server_id: self.server_id,
external_id: self.external_id,
})
}
}
}
impl DescribeAccessInput {
/// Consumes the builder and constructs an Operation<[`DescribeAccess`](crate::operation::DescribeAccess)>
#[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::DescribeAccess,
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::DescribeAccessInput,
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::DescribeAccessInput,
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"),
"TransferService.DescribeAccess",
);
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_access(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeAccess::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeAccess",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeAccessInput`](crate::input::DescribeAccessInput).
pub fn builder() -> crate::input::describe_access_input::Builder {
crate::input::describe_access_input::Builder::default()
}
}
/// See [`DescribeAgreementInput`](crate::input::DescribeAgreementInput).
pub mod describe_agreement_input {
/// A builder for [`DescribeAgreementInput`](crate::input::DescribeAgreementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) agreement_id: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(mut self, input: impl Into<std::string::String>) -> Self {
self.agreement_id = Some(input.into());
self
}
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn set_agreement_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.agreement_id = input;
self
}
/// <p>The server identifier that's associated with the agreement.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The server identifier that's associated with the agreement.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeAgreementInput`](crate::input::DescribeAgreementInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeAgreementInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeAgreementInput {
agreement_id: self.agreement_id,
server_id: self.server_id,
})
}
}
}
impl DescribeAgreementInput {
/// Consumes the builder and constructs an Operation<[`DescribeAgreement`](crate::operation::DescribeAgreement)>
#[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::DescribeAgreement,
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::DescribeAgreementInput,
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::DescribeAgreementInput,
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"),
"TransferService.DescribeAgreement",
);
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_agreement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeAgreement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeAgreement",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeAgreementInput`](crate::input::DescribeAgreementInput).
pub fn builder() -> crate::input::describe_agreement_input::Builder {
crate::input::describe_agreement_input::Builder::default()
}
}
/// See [`DescribeCertificateInput`](crate::input::DescribeCertificateInput).
pub mod describe_certificate_input {
/// A builder for [`DescribeCertificateInput`](crate::input::DescribeCertificateInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) certificate_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_id(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_id = Some(input.into());
self
}
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn set_certificate_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeCertificateInput`](crate::input::DescribeCertificateInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeCertificateInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeCertificateInput {
certificate_id: self.certificate_id,
})
}
}
}
impl DescribeCertificateInput {
/// Consumes the builder and constructs an Operation<[`DescribeCertificate`](crate::operation::DescribeCertificate)>
#[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::DescribeCertificate,
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::DescribeCertificateInput,
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::DescribeCertificateInput,
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"),
"TransferService.DescribeCertificate",
);
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_certificate(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeCertificate::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeCertificate",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeCertificateInput`](crate::input::DescribeCertificateInput).
pub fn builder() -> crate::input::describe_certificate_input::Builder {
crate::input::describe_certificate_input::Builder::default()
}
}
/// See [`DescribeConnectorInput`](crate::input::DescribeConnectorInput).
pub mod describe_connector_input {
/// A builder for [`DescribeConnectorInput`](crate::input::DescribeConnectorInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(mut self, input: impl Into<std::string::String>) -> Self {
self.connector_id = Some(input.into());
self
}
/// <p>The unique identifier for the connector.</p>
pub fn set_connector_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.connector_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeConnectorInput`](crate::input::DescribeConnectorInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeConnectorInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeConnectorInput {
connector_id: self.connector_id,
})
}
}
}
impl DescribeConnectorInput {
/// Consumes the builder and constructs an Operation<[`DescribeConnector`](crate::operation::DescribeConnector)>
#[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::DescribeConnector,
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::DescribeConnectorInput,
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::DescribeConnectorInput,
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"),
"TransferService.DescribeConnector",
);
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_connector(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeConnector::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeConnector",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeConnectorInput`](crate::input::DescribeConnectorInput).
pub fn builder() -> crate::input::describe_connector_input::Builder {
crate::input::describe_connector_input::Builder::default()
}
}
/// See [`DescribeExecutionInput`](crate::input::DescribeExecutionInput).
pub mod describe_execution_input {
/// A builder for [`DescribeExecutionInput`](crate::input::DescribeExecutionInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) execution_id: std::option::Option<std::string::String>,
pub(crate) workflow_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn execution_id(mut self, input: impl Into<std::string::String>) -> Self {
self.execution_id = Some(input.into());
self
}
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn set_execution_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.execution_id = input;
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_id = Some(input.into());
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn set_workflow_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.workflow_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeExecutionInput`](crate::input::DescribeExecutionInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeExecutionInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeExecutionInput {
execution_id: self.execution_id,
workflow_id: self.workflow_id,
})
}
}
}
impl DescribeExecutionInput {
/// Consumes the builder and constructs an Operation<[`DescribeExecution`](crate::operation::DescribeExecution)>
#[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::DescribeExecution,
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::DescribeExecutionInput,
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::DescribeExecutionInput,
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"),
"TransferService.DescribeExecution",
);
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_execution(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeExecution::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeExecution",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeExecutionInput`](crate::input::DescribeExecutionInput).
pub fn builder() -> crate::input::describe_execution_input::Builder {
crate::input::describe_execution_input::Builder::default()
}
}
/// See [`DescribeHostKeyInput`](crate::input::DescribeHostKeyInput).
pub mod describe_host_key_input {
/// A builder for [`DescribeHostKeyInput`](crate::input::DescribeHostKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) host_key_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the server that contains the host key that you want described.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server that contains the host key that you want described.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The identifier of the host key that you want described.</p>
pub fn host_key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key_id = Some(input.into());
self
}
/// <p>The identifier of the host key that you want described.</p>
pub fn set_host_key_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_key_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeHostKeyInput`](crate::input::DescribeHostKeyInput).
pub fn build(
self,
) -> Result<crate::input::DescribeHostKeyInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeHostKeyInput {
server_id: self.server_id,
host_key_id: self.host_key_id,
})
}
}
}
impl DescribeHostKeyInput {
/// Consumes the builder and constructs an Operation<[`DescribeHostKey`](crate::operation::DescribeHostKey)>
#[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::DescribeHostKey,
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::DescribeHostKeyInput,
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::DescribeHostKeyInput,
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"),
"TransferService.DescribeHostKey",
);
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_host_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeHostKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeHostKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeHostKeyInput`](crate::input::DescribeHostKeyInput).
pub fn builder() -> crate::input::describe_host_key_input::Builder {
crate::input::describe_host_key_input::Builder::default()
}
}
/// See [`DescribeProfileInput`](crate::input::DescribeProfileInput).
pub mod describe_profile_input {
/// A builder for [`DescribeProfileInput`](crate::input::DescribeProfileInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the profile that you want described.</p>
pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_id = Some(input.into());
self
}
/// <p>The identifier of the profile that you want described.</p>
pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeProfileInput`](crate::input::DescribeProfileInput).
pub fn build(
self,
) -> Result<crate::input::DescribeProfileInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeProfileInput {
profile_id: self.profile_id,
})
}
}
}
impl DescribeProfileInput {
/// Consumes the builder and constructs an Operation<[`DescribeProfile`](crate::operation::DescribeProfile)>
#[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::DescribeProfile,
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::DescribeProfileInput,
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::DescribeProfileInput,
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"),
"TransferService.DescribeProfile",
);
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_profile(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeProfile",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeProfileInput`](crate::input::DescribeProfileInput).
pub fn builder() -> crate::input::describe_profile_input::Builder {
crate::input::describe_profile_input::Builder::default()
}
}
/// See [`DescribeSecurityPolicyInput`](crate::input::DescribeSecurityPolicyInput).
pub mod describe_security_policy_input {
/// A builder for [`DescribeSecurityPolicyInput`](crate::input::DescribeSecurityPolicyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) security_policy_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(mut self, input: impl Into<std::string::String>) -> Self {
self.security_policy_name = Some(input.into());
self
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn set_security_policy_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_policy_name = input;
self
}
/// Consumes the builder and constructs a [`DescribeSecurityPolicyInput`](crate::input::DescribeSecurityPolicyInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeSecurityPolicyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeSecurityPolicyInput {
security_policy_name: self.security_policy_name,
})
}
}
}
impl DescribeSecurityPolicyInput {
/// Consumes the builder and constructs an Operation<[`DescribeSecurityPolicy`](crate::operation::DescribeSecurityPolicy)>
#[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::DescribeSecurityPolicy,
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::DescribeSecurityPolicyInput,
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::DescribeSecurityPolicyInput,
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"),
"TransferService.DescribeSecurityPolicy",
);
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_security_policy(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeSecurityPolicy::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeSecurityPolicy",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeSecurityPolicyInput`](crate::input::DescribeSecurityPolicyInput).
pub fn builder() -> crate::input::describe_security_policy_input::Builder {
crate::input::describe_security_policy_input::Builder::default()
}
}
/// See [`DescribeServerInput`](crate::input::DescribeServerInput).
pub mod describe_server_input {
/// A builder for [`DescribeServerInput`](crate::input::DescribeServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeServerInput`](crate::input::DescribeServerInput).
pub fn build(
self,
) -> Result<crate::input::DescribeServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeServerInput {
server_id: self.server_id,
})
}
}
}
impl DescribeServerInput {
/// Consumes the builder and constructs an Operation<[`DescribeServer`](crate::operation::DescribeServer)>
#[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::DescribeServer,
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::DescribeServerInput,
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::DescribeServerInput,
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"),
"TransferService.DescribeServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeServerInput`](crate::input::DescribeServerInput).
pub fn builder() -> crate::input::describe_server_input::Builder {
crate::input::describe_server_input::Builder::default()
}
}
/// See [`DescribeUserInput`](crate::input::DescribeUserInput).
pub mod describe_user_input {
/// A builder for [`DescribeUserInput`](crate::input::DescribeUserInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The name of the user assigned to one or more servers. User names are part of the sign-in credentials to use the Transfer Family service and perform file transfer tasks.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>The name of the user assigned to one or more servers. User names are part of the sign-in credentials to use the Transfer Family service and perform file transfer tasks.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`DescribeUserInput`](crate::input::DescribeUserInput).
pub fn build(
self,
) -> Result<crate::input::DescribeUserInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::DescribeUserInput {
server_id: self.server_id,
user_name: self.user_name,
})
}
}
}
impl DescribeUserInput {
/// Consumes the builder and constructs an Operation<[`DescribeUser`](crate::operation::DescribeUser)>
#[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::DescribeUser,
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::DescribeUserInput,
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::DescribeUserInput,
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"),
"TransferService.DescribeUser",
);
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_user(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeUser",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeUserInput`](crate::input::DescribeUserInput).
pub fn builder() -> crate::input::describe_user_input::Builder {
crate::input::describe_user_input::Builder::default()
}
}
/// See [`DescribeWorkflowInput`](crate::input::DescribeWorkflowInput).
pub mod describe_workflow_input {
/// A builder for [`DescribeWorkflowInput`](crate::input::DescribeWorkflowInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) workflow_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_id = Some(input.into());
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn set_workflow_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.workflow_id = input;
self
}
/// Consumes the builder and constructs a [`DescribeWorkflowInput`](crate::input::DescribeWorkflowInput).
pub fn build(
self,
) -> Result<
crate::input::DescribeWorkflowInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::DescribeWorkflowInput {
workflow_id: self.workflow_id,
})
}
}
}
impl DescribeWorkflowInput {
/// Consumes the builder and constructs an Operation<[`DescribeWorkflow`](crate::operation::DescribeWorkflow)>
#[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::DescribeWorkflow,
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::DescribeWorkflowInput,
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::DescribeWorkflowInput,
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"),
"TransferService.DescribeWorkflow",
);
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_workflow(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::DescribeWorkflow::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"DescribeWorkflow",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`DescribeWorkflowInput`](crate::input::DescribeWorkflowInput).
pub fn builder() -> crate::input::describe_workflow_input::Builder {
crate::input::describe_workflow_input::Builder::default()
}
}
/// See [`ImportCertificateInput`](crate::input::ImportCertificateInput).
pub mod import_certificate_input {
/// A builder for [`ImportCertificateInput`](crate::input::ImportCertificateInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) usage: std::option::Option<crate::model::CertificateUsageType>,
pub(crate) certificate: std::option::Option<std::string::String>,
pub(crate) certificate_chain: std::option::Option<std::string::String>,
pub(crate) private_key: std::option::Option<std::string::String>,
pub(crate) active_date: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) inactive_date: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>Specifies whether this certificate is used for signing or encryption.</p>
pub fn usage(mut self, input: crate::model::CertificateUsageType) -> Self {
self.usage = Some(input);
self
}
/// <p>Specifies whether this certificate is used for signing or encryption.</p>
pub fn set_usage(
mut self,
input: std::option::Option<crate::model::CertificateUsageType>,
) -> Self {
self.usage = input;
self
}
/// <p>The file that contains the certificate to import.</p>
pub fn certificate(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate = Some(input.into());
self
}
/// <p>The file that contains the certificate to import.</p>
pub fn set_certificate(mut self, input: std::option::Option<std::string::String>) -> Self {
self.certificate = input;
self
}
/// <p>An optional list of certificates that make up the chain for the certificate that's being imported.</p>
pub fn certificate_chain(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_chain = Some(input.into());
self
}
/// <p>An optional list of certificates that make up the chain for the certificate that's being imported.</p>
pub fn set_certificate_chain(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_chain = input;
self
}
/// <p>The file that contains the private key for the certificate that's being imported.</p>
pub fn private_key(mut self, input: impl Into<std::string::String>) -> Self {
self.private_key = Some(input.into());
self
}
/// <p>The file that contains the private key for the certificate that's being imported.</p>
pub fn set_private_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.private_key = input;
self
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn active_date(mut self, input: aws_smithy_types::DateTime) -> Self {
self.active_date = Some(input);
self
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn set_active_date(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.active_date = input;
self
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn inactive_date(mut self, input: aws_smithy_types::DateTime) -> Self {
self.inactive_date = Some(input);
self
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn set_inactive_date(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.inactive_date = input;
self
}
/// <p>A short description that helps identify the certificate. </p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A short description that helps identify the certificate. </p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for certificates.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for certificates.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ImportCertificateInput`](crate::input::ImportCertificateInput).
pub fn build(
self,
) -> Result<
crate::input::ImportCertificateInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ImportCertificateInput {
usage: self.usage,
certificate: self.certificate,
certificate_chain: self.certificate_chain,
private_key: self.private_key,
active_date: self.active_date,
inactive_date: self.inactive_date,
description: self.description,
tags: self.tags,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("usage", &self.usage);
formatter.field("certificate", &"*** Sensitive Data Redacted ***");
formatter.field("certificate_chain", &"*** Sensitive Data Redacted ***");
formatter.field("private_key", &"*** Sensitive Data Redacted ***");
formatter.field("active_date", &self.active_date);
formatter.field("inactive_date", &self.inactive_date);
formatter.field("description", &self.description);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
}
impl ImportCertificateInput {
/// Consumes the builder and constructs an Operation<[`ImportCertificate`](crate::operation::ImportCertificate)>
#[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::ImportCertificate,
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::ImportCertificateInput,
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::ImportCertificateInput,
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"),
"TransferService.ImportCertificate",
);
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_import_certificate(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ImportCertificate::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ImportCertificate",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ImportCertificateInput`](crate::input::ImportCertificateInput).
pub fn builder() -> crate::input::import_certificate_input::Builder {
crate::input::import_certificate_input::Builder::default()
}
}
/// See [`ImportHostKeyInput`](crate::input::ImportHostKeyInput).
pub mod import_host_key_input {
/// A builder for [`ImportHostKeyInput`](crate::input::ImportHostKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) host_key_body: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>The identifier of the server that contains the host key that you are importing.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server that contains the host key that you are importing.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn host_key_body(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key_body = Some(input.into());
self
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn set_host_key_body(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.host_key_body = input;
self
}
/// <p>The text description that identifies this host key.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>The text description that identifies this host key.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs that can be used to group and search for host keys.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs that can be used to group and search for host keys.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`ImportHostKeyInput`](crate::input::ImportHostKeyInput).
pub fn build(
self,
) -> Result<crate::input::ImportHostKeyInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ImportHostKeyInput {
server_id: self.server_id,
host_key_body: self.host_key_body,
description: self.description,
tags: self.tags,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("server_id", &self.server_id);
formatter.field("host_key_body", &"*** Sensitive Data Redacted ***");
formatter.field("description", &self.description);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
}
impl ImportHostKeyInput {
/// Consumes the builder and constructs an Operation<[`ImportHostKey`](crate::operation::ImportHostKey)>
#[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::ImportHostKey,
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::ImportHostKeyInput,
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::ImportHostKeyInput,
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"),
"TransferService.ImportHostKey",
);
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_import_host_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ImportHostKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ImportHostKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ImportHostKeyInput`](crate::input::ImportHostKeyInput).
pub fn builder() -> crate::input::import_host_key_input::Builder {
crate::input::import_host_key_input::Builder::default()
}
}
/// See [`ImportSshPublicKeyInput`](crate::input::ImportSshPublicKeyInput).
pub mod import_ssh_public_key_input {
/// A builder for [`ImportSshPublicKeyInput`](crate::input::ImportSshPublicKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) ssh_public_key_body: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn ssh_public_key_body(mut self, input: impl Into<std::string::String>) -> Self {
self.ssh_public_key_body = Some(input.into());
self
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn set_ssh_public_key_body(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.ssh_public_key_body = input;
self
}
/// <p>The name of the user account that is assigned to one or more servers.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>The name of the user account that is assigned to one or more servers.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`ImportSshPublicKeyInput`](crate::input::ImportSshPublicKeyInput).
pub fn build(
self,
) -> Result<
crate::input::ImportSshPublicKeyInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ImportSshPublicKeyInput {
server_id: self.server_id,
ssh_public_key_body: self.ssh_public_key_body,
user_name: self.user_name,
})
}
}
}
impl ImportSshPublicKeyInput {
/// Consumes the builder and constructs an Operation<[`ImportSshPublicKey`](crate::operation::ImportSshPublicKey)>
#[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::ImportSshPublicKey,
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::ImportSshPublicKeyInput,
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::ImportSshPublicKeyInput,
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"),
"TransferService.ImportSshPublicKey",
);
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_import_ssh_public_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ImportSshPublicKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ImportSshPublicKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ImportSshPublicKeyInput`](crate::input::ImportSshPublicKeyInput).
pub fn builder() -> crate::input::import_ssh_public_key_input::Builder {
crate::input::import_ssh_public_key_input::Builder::default()
}
}
/// See [`ListAccessesInput`](crate::input::ListAccessesInput).
pub mod list_accesses_input {
/// A builder for [`ListAccessesInput`](crate::input::ListAccessesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the maximum number of access SIDs to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the maximum number of access SIDs to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you can get additional results from the <code>ListAccesses</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional accesses.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you can get additional results from the <code>ListAccesses</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional accesses.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`ListAccessesInput`](crate::input::ListAccessesInput).
pub fn build(
self,
) -> Result<crate::input::ListAccessesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListAccessesInput {
max_results: self.max_results,
next_token: self.next_token,
server_id: self.server_id,
})
}
}
}
impl ListAccessesInput {
/// Consumes the builder and constructs an Operation<[`ListAccesses`](crate::operation::ListAccesses)>
#[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::ListAccesses,
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::ListAccessesInput,
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::ListAccessesInput,
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"),
"TransferService.ListAccesses",
);
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_accesses(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListAccesses::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListAccesses",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListAccessesInput`](crate::input::ListAccessesInput).
pub fn builder() -> crate::input::list_accesses_input::Builder {
crate::input::list_accesses_input::Builder::default()
}
}
/// See [`ListAgreementsInput`](crate::input::ListAgreementsInput).
pub mod list_agreements_input {
/// A builder for [`ListAgreementsInput`](crate::input::ListAgreementsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of agreements to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of agreements to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you can get additional results from the <code>ListAgreements</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional agreements.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you can get additional results from the <code>ListAgreements</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional agreements.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The identifier of the server for which you want a list of agreements.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server for which you want a list of agreements.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`ListAgreementsInput`](crate::input::ListAgreementsInput).
pub fn build(
self,
) -> Result<crate::input::ListAgreementsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListAgreementsInput {
max_results: self.max_results,
next_token: self.next_token,
server_id: self.server_id,
})
}
}
}
impl ListAgreementsInput {
/// Consumes the builder and constructs an Operation<[`ListAgreements`](crate::operation::ListAgreements)>
#[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::ListAgreements,
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::ListAgreementsInput,
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::ListAgreementsInput,
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"),
"TransferService.ListAgreements",
);
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_agreements(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListAgreements::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListAgreements",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListAgreementsInput`](crate::input::ListAgreementsInput).
pub fn builder() -> crate::input::list_agreements_input::Builder {
crate::input::list_agreements_input::Builder::default()
}
}
/// See [`ListCertificatesInput`](crate::input::ListCertificatesInput).
pub mod list_certificates_input {
/// A builder for [`ListCertificatesInput`](crate::input::ListCertificatesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of certificates to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of certificates to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you can get additional results from the <code>ListCertificates</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional certificates.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you can get additional results from the <code>ListCertificates</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional certificates.</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 [`ListCertificatesInput`](crate::input::ListCertificatesInput).
pub fn build(
self,
) -> Result<
crate::input::ListCertificatesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListCertificatesInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListCertificatesInput {
/// Consumes the builder and constructs an Operation<[`ListCertificates`](crate::operation::ListCertificates)>
#[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::ListCertificates,
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::ListCertificatesInput,
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::ListCertificatesInput,
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"),
"TransferService.ListCertificates",
);
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_certificates(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListCertificates::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListCertificates",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListCertificatesInput`](crate::input::ListCertificatesInput).
pub fn builder() -> crate::input::list_certificates_input::Builder {
crate::input::list_certificates_input::Builder::default()
}
}
/// See [`ListConnectorsInput`](crate::input::ListConnectorsInput).
pub mod list_connectors_input {
/// A builder for [`ListConnectorsInput`](crate::input::ListConnectorsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of connectors to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of connectors to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you can get additional results from the <code>ListConnectors</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional connectors.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you can get additional results from the <code>ListConnectors</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional connectors.</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 [`ListConnectorsInput`](crate::input::ListConnectorsInput).
pub fn build(
self,
) -> Result<crate::input::ListConnectorsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListConnectorsInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListConnectorsInput {
/// Consumes the builder and constructs an Operation<[`ListConnectors`](crate::operation::ListConnectors)>
#[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::ListConnectors,
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::ListConnectorsInput,
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::ListConnectorsInput,
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"),
"TransferService.ListConnectors",
);
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_connectors(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListConnectors::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListConnectors",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListConnectorsInput`](crate::input::ListConnectorsInput).
pub fn builder() -> crate::input::list_connectors_input::Builder {
crate::input::list_connectors_input::Builder::default()
}
}
/// See [`ListExecutionsInput`](crate::input::ListExecutionsInput).
pub mod list_executions_input {
/// A builder for [`ListExecutionsInput`](crate::input::ListExecutionsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) workflow_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the maximum number of executions to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the maximum number of executions to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p> <code>ListExecutions</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional executions.</p>
/// <p> This is useful for pagination, for instance. If you have 100 executions for a workflow, you might only want to list first 10. If so, call the API by specifying the <code>max-results</code>: </p>
/// <p> <code>aws transfer list-executions --max-results 10</code> </p>
/// <p> This returns details for the first 10 executions, as well as the pointer (<code>NextToken</code>) to the eleventh execution. You can now call the API again, supplying the <code>NextToken</code> value you received: </p>
/// <p> <code>aws transfer list-executions --max-results 10 --next-token $somePointerReturnedFromPreviousListResult</code> </p>
/// <p> This call returns the next 10 executions, the 11th through the 20th. You can then repeat the call until the details for all 100 executions have been returned. </p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p> <code>ListExecutions</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional executions.</p>
/// <p> This is useful for pagination, for instance. If you have 100 executions for a workflow, you might only want to list first 10. If so, call the API by specifying the <code>max-results</code>: </p>
/// <p> <code>aws transfer list-executions --max-results 10</code> </p>
/// <p> This returns details for the first 10 executions, as well as the pointer (<code>NextToken</code>) to the eleventh execution. You can now call the API again, supplying the <code>NextToken</code> value you received: </p>
/// <p> <code>aws transfer list-executions --max-results 10 --next-token $somePointerReturnedFromPreviousListResult</code> </p>
/// <p> This call returns the next 10 executions, the 11th through the 20th. You can then repeat the call until the details for all 100 executions have been returned. </p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_id = Some(input.into());
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn set_workflow_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.workflow_id = input;
self
}
/// Consumes the builder and constructs a [`ListExecutionsInput`](crate::input::ListExecutionsInput).
pub fn build(
self,
) -> Result<crate::input::ListExecutionsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListExecutionsInput {
max_results: self.max_results,
next_token: self.next_token,
workflow_id: self.workflow_id,
})
}
}
}
impl ListExecutionsInput {
/// Consumes the builder and constructs an Operation<[`ListExecutions`](crate::operation::ListExecutions)>
#[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::ListExecutions,
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::ListExecutionsInput,
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::ListExecutionsInput,
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"),
"TransferService.ListExecutions",
);
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_executions(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListExecutions::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListExecutions",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListExecutionsInput`](crate::input::ListExecutionsInput).
pub fn builder() -> crate::input::list_executions_input::Builder {
crate::input::list_executions_input::Builder::default()
}
}
/// See [`ListHostKeysInput`](crate::input::ListHostKeysInput).
pub mod list_host_keys_input {
/// A builder for [`ListHostKeysInput`](crate::input::ListHostKeysInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The maximum number of host keys to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of host keys to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListHostKeys</code> to continue listing results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListHostKeys</code> to continue listing results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>The identifier of the server that contains the host keys that you want to view.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server that contains the host keys that you want to view.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`ListHostKeysInput`](crate::input::ListHostKeysInput).
pub fn build(
self,
) -> Result<crate::input::ListHostKeysInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListHostKeysInput {
max_results: self.max_results,
next_token: self.next_token,
server_id: self.server_id,
})
}
}
}
impl ListHostKeysInput {
/// Consumes the builder and constructs an Operation<[`ListHostKeys`](crate::operation::ListHostKeys)>
#[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::ListHostKeys,
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::ListHostKeysInput,
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::ListHostKeysInput,
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"),
"TransferService.ListHostKeys",
);
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_host_keys(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListHostKeys::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListHostKeys",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListHostKeysInput`](crate::input::ListHostKeysInput).
pub fn builder() -> crate::input::list_host_keys_input::Builder {
crate::input::list_host_keys_input::Builder::default()
}
}
/// See [`ListProfilesInput`](crate::input::ListProfilesInput).
pub mod list_profiles_input {
/// A builder for [`ListProfilesInput`](crate::input::ListProfilesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) profile_type: std::option::Option<crate::model::ProfileType>,
}
impl Builder {
/// <p>The maximum number of profiles to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>The maximum number of profiles to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListProfiles</code> to continue listing results.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListProfiles</code> to continue listing results.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>Indicates whether to list only <code>LOCAL</code> type profiles or only <code>PARTNER</code> type profiles. If not supplied in the request, the command lists all types of profiles.</p>
pub fn profile_type(mut self, input: crate::model::ProfileType) -> Self {
self.profile_type = Some(input);
self
}
/// <p>Indicates whether to list only <code>LOCAL</code> type profiles or only <code>PARTNER</code> type profiles. If not supplied in the request, the command lists all types of profiles.</p>
pub fn set_profile_type(
mut self,
input: std::option::Option<crate::model::ProfileType>,
) -> Self {
self.profile_type = input;
self
}
/// Consumes the builder and constructs a [`ListProfilesInput`](crate::input::ListProfilesInput).
pub fn build(
self,
) -> Result<crate::input::ListProfilesInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListProfilesInput {
max_results: self.max_results,
next_token: self.next_token,
profile_type: self.profile_type,
})
}
}
}
impl ListProfilesInput {
/// Consumes the builder and constructs an Operation<[`ListProfiles`](crate::operation::ListProfiles)>
#[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::ListProfiles,
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::ListProfilesInput,
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::ListProfilesInput,
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"),
"TransferService.ListProfiles",
);
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_profiles(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListProfiles::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListProfiles",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListProfilesInput`](crate::input::ListProfilesInput).
pub fn builder() -> crate::input::list_profiles_input::Builder {
crate::input::list_profiles_input::Builder::default()
}
}
/// See [`ListSecurityPoliciesInput`](crate::input::ListSecurityPoliciesInput).
pub mod list_security_policies_input {
/// A builder for [`ListSecurityPoliciesInput`](crate::input::ListSecurityPoliciesInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the number of security policies to return as a response to the <code>ListSecurityPolicies</code> query.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the number of security policies to return as a response to the <code>ListSecurityPolicies</code> query.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When additional results are obtained from the <code>ListSecurityPolicies</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional security policies.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When additional results are obtained from the <code>ListSecurityPolicies</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional security policies.</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 [`ListSecurityPoliciesInput`](crate::input::ListSecurityPoliciesInput).
pub fn build(
self,
) -> Result<
crate::input::ListSecurityPoliciesInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListSecurityPoliciesInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListSecurityPoliciesInput {
/// Consumes the builder and constructs an Operation<[`ListSecurityPolicies`](crate::operation::ListSecurityPolicies)>
#[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::ListSecurityPolicies,
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::ListSecurityPoliciesInput,
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::ListSecurityPoliciesInput,
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"),
"TransferService.ListSecurityPolicies",
);
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_security_policies(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListSecurityPolicies::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListSecurityPolicies",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListSecurityPoliciesInput`](crate::input::ListSecurityPoliciesInput).
pub fn builder() -> crate::input::list_security_policies_input::Builder {
crate::input::list_security_policies_input::Builder::default()
}
}
/// See [`ListServersInput`](crate::input::ListServersInput).
pub mod list_servers_input {
/// A builder for [`ListServersInput`](crate::input::ListServersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the number of servers to return as a response to the <code>ListServers</code> query.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the number of servers to return as a response to the <code>ListServers</code> query.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When additional results are obtained from the <code>ListServers</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional servers.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When additional results are obtained from the <code>ListServers</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional servers.</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 [`ListServersInput`](crate::input::ListServersInput).
pub fn build(
self,
) -> Result<crate::input::ListServersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListServersInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListServersInput {
/// Consumes the builder and constructs an Operation<[`ListServers`](crate::operation::ListServers)>
#[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::ListServers,
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::ListServersInput,
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::ListServersInput,
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"),
"TransferService.ListServers",
);
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_servers(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListServers::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListServers",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListServersInput`](crate::input::ListServersInput).
pub fn builder() -> crate::input::list_servers_input::Builder {
crate::input::list_servers_input::Builder::default()
}
}
/// See [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub mod list_tags_for_resource_input {
/// A builder for [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Requests the tags associated with a particular Amazon Resource Name (ARN). An ARN is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
/// <p>Requests the tags associated with a particular Amazon Resource Name (ARN). An ARN is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
/// <p>Specifies the number of tags to return as a response to the <code>ListTagsForResource</code> request.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the number of tags to return as a response to the <code>ListTagsForResource</code> request.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you request additional results from the <code>ListTagsForResource</code> operation, a <code>NextToken</code> parameter is returned in the input. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional tags.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you request additional results from the <code>ListTagsForResource</code> operation, a <code>NextToken</code> parameter is returned in the input. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional tags.</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 [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub fn build(
self,
) -> Result<
crate::input::ListTagsForResourceInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::ListTagsForResourceInput {
arn: self.arn,
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListTagsForResourceInput {
/// Consumes the builder and constructs an Operation<[`ListTagsForResource`](crate::operation::ListTagsForResource)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::ListTagsForResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::ListTagsForResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::ListTagsForResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::error::BuildError,
> {
let mut uri = String::new();
uri_base(input, &mut uri)?;
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"),
"TransferService.ListTagsForResource",
);
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_resource(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListTagsForResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListTagsForResource",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput).
pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
crate::input::list_tags_for_resource_input::Builder::default()
}
}
/// See [`ListUsersInput`](crate::input::ListUsersInput).
pub mod list_users_input {
/// A builder for [`ListUsersInput`](crate::input::ListUsersInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the number of users to return as a response to the <code>ListUsers</code> request.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the number of users to return as a response to the <code>ListUsers</code> request.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p>When you can get additional results from the <code>ListUsers</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional users.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p>When you can get additional results from the <code>ListUsers</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional users.</p>
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`ListUsersInput`](crate::input::ListUsersInput).
pub fn build(
self,
) -> Result<crate::input::ListUsersInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListUsersInput {
max_results: self.max_results,
next_token: self.next_token,
server_id: self.server_id,
})
}
}
}
impl ListUsersInput {
/// Consumes the builder and constructs an Operation<[`ListUsers`](crate::operation::ListUsers)>
#[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::ListUsers,
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::ListUsersInput,
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::ListUsersInput,
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"),
"TransferService.ListUsers",
);
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_users(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op =
aws_smithy_http::operation::Operation::new(request, crate::operation::ListUsers::new())
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListUsers",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListUsersInput`](crate::input::ListUsersInput).
pub fn builder() -> crate::input::list_users_input::Builder {
crate::input::list_users_input::Builder::default()
}
}
/// See [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub mod list_workflows_input {
/// A builder for [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) max_results: std::option::Option<i32>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>Specifies the maximum number of workflows to return.</p>
pub fn max_results(mut self, input: i32) -> Self {
self.max_results = Some(input);
self
}
/// <p>Specifies the maximum number of workflows to return.</p>
pub fn set_max_results(mut self, input: std::option::Option<i32>) -> Self {
self.max_results = input;
self
}
/// <p> <code>ListWorkflows</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional workflows.</p>
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
/// <p> <code>ListWorkflows</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional workflows.</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 [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub fn build(
self,
) -> Result<crate::input::ListWorkflowsInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::ListWorkflowsInput {
max_results: self.max_results,
next_token: self.next_token,
})
}
}
}
impl ListWorkflowsInput {
/// Consumes the builder and constructs an Operation<[`ListWorkflows`](crate::operation::ListWorkflows)>
#[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::ListWorkflows,
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::ListWorkflowsInput,
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::ListWorkflowsInput,
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"),
"TransferService.ListWorkflows",
);
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_workflows(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::ListWorkflows::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"ListWorkflows",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`ListWorkflowsInput`](crate::input::ListWorkflowsInput).
pub fn builder() -> crate::input::list_workflows_input::Builder {
crate::input::list_workflows_input::Builder::default()
}
}
/// See [`SendWorkflowStepStateInput`](crate::input::SendWorkflowStepStateInput).
pub mod send_workflow_step_state_input {
/// A builder for [`SendWorkflowStepStateInput`](crate::input::SendWorkflowStepStateInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) workflow_id: std::option::Option<std::string::String>,
pub(crate) execution_id: std::option::Option<std::string::String>,
pub(crate) token: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<crate::model::CustomStepStatus>,
}
impl Builder {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(mut self, input: impl Into<std::string::String>) -> Self {
self.workflow_id = Some(input.into());
self
}
/// <p>A unique identifier for the workflow.</p>
pub fn set_workflow_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.workflow_id = input;
self
}
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn execution_id(mut self, input: impl Into<std::string::String>) -> Self {
self.execution_id = Some(input.into());
self
}
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn set_execution_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.execution_id = input;
self
}
/// <p>Used to distinguish between multiple callbacks for multiple Lambda steps within the same execution.</p>
pub fn token(mut self, input: impl Into<std::string::String>) -> Self {
self.token = Some(input.into());
self
}
/// <p>Used to distinguish between multiple callbacks for multiple Lambda steps within the same execution.</p>
pub fn set_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.token = input;
self
}
/// <p>Indicates whether the specified step succeeded or failed.</p>
pub fn status(mut self, input: crate::model::CustomStepStatus) -> Self {
self.status = Some(input);
self
}
/// <p>Indicates whether the specified step succeeded or failed.</p>
pub fn set_status(
mut self,
input: std::option::Option<crate::model::CustomStepStatus>,
) -> Self {
self.status = input;
self
}
/// Consumes the builder and constructs a [`SendWorkflowStepStateInput`](crate::input::SendWorkflowStepStateInput).
pub fn build(
self,
) -> Result<
crate::input::SendWorkflowStepStateInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::SendWorkflowStepStateInput {
workflow_id: self.workflow_id,
execution_id: self.execution_id,
token: self.token,
status: self.status,
})
}
}
}
impl SendWorkflowStepStateInput {
/// Consumes the builder and constructs an Operation<[`SendWorkflowStepState`](crate::operation::SendWorkflowStepState)>
#[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::SendWorkflowStepState,
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::SendWorkflowStepStateInput,
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::SendWorkflowStepStateInput,
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"),
"TransferService.SendWorkflowStepState",
);
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_send_workflow_step_state(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::SendWorkflowStepState::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"SendWorkflowStepState",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`SendWorkflowStepStateInput`](crate::input::SendWorkflowStepStateInput).
pub fn builder() -> crate::input::send_workflow_step_state_input::Builder {
crate::input::send_workflow_step_state_input::Builder::default()
}
}
/// See [`StartFileTransferInput`](crate::input::StartFileTransferInput).
pub mod start_file_transfer_input {
/// A builder for [`StartFileTransferInput`](crate::input::StartFileTransferInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_id: std::option::Option<std::string::String>,
pub(crate) send_file_paths: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The unique identifier for the connector. </p>
pub fn connector_id(mut self, input: impl Into<std::string::String>) -> Self {
self.connector_id = Some(input.into());
self
}
/// <p>The unique identifier for the connector. </p>
pub fn set_connector_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.connector_id = input;
self
}
/// Appends an item to `send_file_paths`.
///
/// To override the contents of this collection use [`set_send_file_paths`](Self::set_send_file_paths).
///
/// <p>An array of strings. Each string represents the absolute path for one outbound file transfer. For example, <code> <i>DOC-EXAMPLE-BUCKET</i>/<i>myfile.txt</i> </code>. </p>
pub fn send_file_paths(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.send_file_paths.unwrap_or_default();
v.push(input.into());
self.send_file_paths = Some(v);
self
}
/// <p>An array of strings. Each string represents the absolute path for one outbound file transfer. For example, <code> <i>DOC-EXAMPLE-BUCKET</i>/<i>myfile.txt</i> </code>. </p>
pub fn set_send_file_paths(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.send_file_paths = input;
self
}
/// Consumes the builder and constructs a [`StartFileTransferInput`](crate::input::StartFileTransferInput).
pub fn build(
self,
) -> Result<
crate::input::StartFileTransferInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::StartFileTransferInput {
connector_id: self.connector_id,
send_file_paths: self.send_file_paths,
})
}
}
}
impl StartFileTransferInput {
/// Consumes the builder and constructs an Operation<[`StartFileTransfer`](crate::operation::StartFileTransfer)>
#[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::StartFileTransfer,
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::StartFileTransferInput,
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::StartFileTransferInput,
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"),
"TransferService.StartFileTransfer",
);
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_file_transfer(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartFileTransfer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartFileTransfer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartFileTransferInput`](crate::input::StartFileTransferInput).
pub fn builder() -> crate::input::start_file_transfer_input::Builder {
crate::input::start_file_transfer_input::Builder::default()
}
}
/// See [`StartServerInput`](crate::input::StartServerInput).
pub mod start_server_input {
/// A builder for [`StartServerInput`](crate::input::StartServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server that you start.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that you start.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`StartServerInput`](crate::input::StartServerInput).
pub fn build(
self,
) -> Result<crate::input::StartServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StartServerInput {
server_id: self.server_id,
})
}
}
}
impl StartServerInput {
/// Consumes the builder and constructs an Operation<[`StartServer`](crate::operation::StartServer)>
#[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::StartServer,
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::StartServerInput,
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::StartServerInput,
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"),
"TransferService.StartServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StartServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StartServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StartServerInput`](crate::input::StartServerInput).
pub fn builder() -> crate::input::start_server_input::Builder {
crate::input::start_server_input::Builder::default()
}
}
/// See [`StopServerInput`](crate::input::StopServerInput).
pub mod stop_server_input {
/// A builder for [`StopServerInput`](crate::input::StopServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned unique identifier for a server that you stopped.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server that you stopped.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// Consumes the builder and constructs a [`StopServerInput`](crate::input::StopServerInput).
pub fn build(
self,
) -> Result<crate::input::StopServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::StopServerInput {
server_id: self.server_id,
})
}
}
}
impl StopServerInput {
/// Consumes the builder and constructs an Operation<[`StopServer`](crate::operation::StopServer)>
#[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::StopServer,
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::StopServerInput,
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::StopServerInput,
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"),
"TransferService.StopServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::StopServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"StopServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`StopServerInput`](crate::input::StopServerInput).
pub fn builder() -> crate::input::stop_server_input::Builder {
crate::input::stop_server_input::Builder::default()
}
}
/// See [`TagResourceInput`](crate::input::TagResourceInput).
pub mod tag_resource_input {
/// A builder for [`TagResourceInput`](crate::input::TagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl Builder {
/// <p>An Amazon Resource Name (ARN) for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
/// <p>An Amazon Resource Name (ARN) for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
/// Appends an item to `tags`.
///
/// To override the contents of this collection use [`set_tags`](Self::set_tags).
///
/// <p>Key-value pairs assigned to ARNs that you can use to group and search for resources by type. You can attach this metadata to user accounts for any purpose.</p>
pub fn tags(mut self, input: crate::model::Tag) -> Self {
let mut v = self.tags.unwrap_or_default();
v.push(input);
self.tags = Some(v);
self
}
/// <p>Key-value pairs assigned to ARNs that you can use to group and search for resources by type. You can attach this metadata to user accounts for any purpose.</p>
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
/// Consumes the builder and constructs a [`TagResourceInput`](crate::input::TagResourceInput).
pub fn build(
self,
) -> Result<crate::input::TagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::TagResourceInput {
arn: self.arn,
tags: self.tags,
})
}
}
}
impl TagResourceInput {
/// Consumes the builder and constructs an Operation<[`TagResource`](crate::operation::TagResource)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::TagResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::TagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::TagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::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"),
"TransferService.TagResource",
);
builder
};
let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = aws_smithy_http::body::SdkBody::from(
crate::operation_ser::serialize_operation_crate_operation_tag_resource(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::TagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"TagResource",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput).
pub fn builder() -> crate::input::tag_resource_input::Builder {
crate::input::tag_resource_input::Builder::default()
}
}
/// See [`TestIdentityProviderInput`](crate::input::TestIdentityProviderInput).
pub mod test_identity_provider_input {
/// A builder for [`TestIdentityProviderInput`](crate::input::TestIdentityProviderInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) server_protocol: std::option::Option<crate::model::Protocol>,
pub(crate) source_ip: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
pub(crate) user_password: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A system-assigned identifier for a specific server. That server's user authentication method is tested with a user name and password.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned identifier for a specific server. That server's user authentication method is tested with a user name and password.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The type of file transfer protocol to be tested.</p>
/// <p>The available protocols are:</p>
/// <ul>
/// <li> <p>Secure Shell (SSH) File Transfer Protocol (SFTP)</p> </li>
/// <li> <p>File Transfer Protocol Secure (FTPS)</p> </li>
/// <li> <p>File Transfer Protocol (FTP)</p> </li>
/// </ul>
pub fn server_protocol(mut self, input: crate::model::Protocol) -> Self {
self.server_protocol = Some(input);
self
}
/// <p>The type of file transfer protocol to be tested.</p>
/// <p>The available protocols are:</p>
/// <ul>
/// <li> <p>Secure Shell (SSH) File Transfer Protocol (SFTP)</p> </li>
/// <li> <p>File Transfer Protocol Secure (FTPS)</p> </li>
/// <li> <p>File Transfer Protocol (FTP)</p> </li>
/// </ul>
pub fn set_server_protocol(
mut self,
input: std::option::Option<crate::model::Protocol>,
) -> Self {
self.server_protocol = input;
self
}
/// <p>The source IP address of the user account to be tested.</p>
pub fn source_ip(mut self, input: impl Into<std::string::String>) -> Self {
self.source_ip = Some(input.into());
self
}
/// <p>The source IP address of the user account to be tested.</p>
pub fn set_source_ip(mut self, input: std::option::Option<std::string::String>) -> Self {
self.source_ip = input;
self
}
/// <p>The name of the user account to be tested.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>The name of the user account to be tested.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// <p>The password of the user account to be tested.</p>
pub fn user_password(mut self, input: impl Into<std::string::String>) -> Self {
self.user_password = Some(input.into());
self
}
/// <p>The password of the user account to be tested.</p>
pub fn set_user_password(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.user_password = input;
self
}
/// Consumes the builder and constructs a [`TestIdentityProviderInput`](crate::input::TestIdentityProviderInput).
pub fn build(
self,
) -> Result<
crate::input::TestIdentityProviderInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::TestIdentityProviderInput {
server_id: self.server_id,
server_protocol: self.server_protocol,
source_ip: self.source_ip,
user_name: self.user_name,
user_password: self.user_password,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("server_id", &self.server_id);
formatter.field("server_protocol", &self.server_protocol);
formatter.field("source_ip", &self.source_ip);
formatter.field("user_name", &self.user_name);
formatter.field("user_password", &"*** Sensitive Data Redacted ***");
formatter.finish()
}
}
}
impl TestIdentityProviderInput {
/// Consumes the builder and constructs an Operation<[`TestIdentityProvider`](crate::operation::TestIdentityProvider)>
#[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::TestIdentityProvider,
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::TestIdentityProviderInput,
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::TestIdentityProviderInput,
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"),
"TransferService.TestIdentityProvider",
);
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_test_identity_provider(
&self,
)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::TestIdentityProvider::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"TestIdentityProvider",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`TestIdentityProviderInput`](crate::input::TestIdentityProviderInput).
pub fn builder() -> crate::input::test_identity_provider_input::Builder {
crate::input::test_identity_provider_input::Builder::default()
}
}
/// See [`UntagResourceInput`](crate::input::UntagResourceInput).
pub mod untag_resource_input {
/// A builder for [`UntagResourceInput`](crate::input::UntagResourceInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The value of the resource that will have the tag removed. An Amazon Resource Name (ARN) is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
/// <p>The value of the resource that will have the tag removed. An Amazon Resource Name (ARN) is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
/// Appends an item to `tag_keys`.
///
/// To override the contents of this collection use [`set_tag_keys`](Self::set_tag_keys).
///
/// <p>TagKeys are key-value pairs assigned to ARNs that can be used to group and search for resources by type. This metadata can be attached to resources for any purpose.</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>TagKeys are key-value pairs assigned to ARNs that can be used to group and search for resources by type. This metadata can be attached to resources for any purpose.</p>
pub fn set_tag_keys(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.tag_keys = input;
self
}
/// Consumes the builder and constructs a [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn build(
self,
) -> Result<crate::input::UntagResourceInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UntagResourceInput {
arn: self.arn,
tag_keys: self.tag_keys,
})
}
}
}
impl UntagResourceInput {
/// Consumes the builder and constructs an Operation<[`UntagResource`](crate::operation::UntagResource)>
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> std::result::Result<
aws_smithy_http::operation::Operation<
crate::operation::UntagResource,
aws_http::retry::AwsResponseRetryClassifier,
>,
aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_dual_stack(_config.use_dual_stack)
.set_use_fips(_config.use_fips)
.set_endpoint(_config.endpoint_url.clone())
.build()
.map_err(|err| {
aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
Some(params),
),
Err(e) => (Err(e), None),
};
let mut request = {
fn uri_base(
_input: &crate::input::UntagResourceInput,
output: &mut String,
) -> Result<(), aws_smithy_http::operation::error::BuildError> {
write!(output, "/").expect("formatting should succeed");
Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::input::UntagResourceInput,
builder: http::request::Builder,
) -> std::result::Result<
http::request::Builder,
aws_smithy_http::operation::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"),
"TransferService.UntagResource",
);
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_untag_resource(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UntagResource::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UntagResource",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput).
pub fn builder() -> crate::input::untag_resource_input::Builder {
crate::input::untag_resource_input::Builder::default()
}
}
/// See [`UpdateAccessInput`](crate::input::UpdateAccessInput).
pub mod update_access_input {
/// A builder for [`UpdateAccessInput`](crate::input::UpdateAccessInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) home_directory: std::option::Option<std::string::String>,
pub(crate) home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
pub(crate) home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
pub(crate) policy: std::option::Option<std::string::String>,
pub(crate) posix_profile: std::option::Option<crate::model::PosixProfile>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) external_id: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.home_directory = Some(input.into());
self
}
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn set_home_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.home_directory = input;
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(mut self, input: crate::model::HomeDirectoryType) -> Self {
self.home_directory_type = Some(input);
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn set_home_directory_type(
mut self,
input: std::option::Option<crate::model::HomeDirectoryType>,
) -> Self {
self.home_directory_type = input;
self
}
/// Appends an item to `home_directory_mappings`.
///
/// To override the contents of this collection use [`set_home_directory_mappings`](Self::set_home_directory_mappings).
///
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
mut self,
input: crate::model::HomeDirectoryMapEntry,
) -> Self {
let mut v = self.home_directory_mappings.unwrap_or_default();
v.push(input);
self.home_directory_mappings = Some(v);
self
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn set_home_directory_mappings(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
) -> Self {
self.home_directory_mappings = input;
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web ServicesSecurity Token Service API Reference</i>.</p>
/// </note>
pub fn policy(mut self, input: impl Into<std::string::String>) -> Self {
self.policy = Some(input.into());
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web ServicesSecurity Token Service API Reference</i>.</p>
/// </note>
pub fn set_policy(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy = input;
self
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(mut self, input: crate::model::PosixProfile) -> Self {
self.posix_profile = Some(input);
self
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn set_posix_profile(
mut self,
input: std::option::Option<crate::model::PosixProfile>,
) -> Self {
self.posix_profile = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(mut self, input: impl Into<std::string::String>) -> Self {
self.external_id = Some(input.into());
self
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn set_external_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.external_id = input;
self
}
/// Consumes the builder and constructs a [`UpdateAccessInput`](crate::input::UpdateAccessInput).
pub fn build(
self,
) -> Result<crate::input::UpdateAccessInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateAccessInput {
home_directory: self.home_directory,
home_directory_type: self.home_directory_type,
home_directory_mappings: self.home_directory_mappings,
policy: self.policy,
posix_profile: self.posix_profile,
role: self.role,
server_id: self.server_id,
external_id: self.external_id,
})
}
}
}
impl UpdateAccessInput {
/// Consumes the builder and constructs an Operation<[`UpdateAccess`](crate::operation::UpdateAccess)>
#[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::UpdateAccess,
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::UpdateAccessInput,
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::UpdateAccessInput,
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"),
"TransferService.UpdateAccess",
);
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_access(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateAccess::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateAccess",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateAccessInput`](crate::input::UpdateAccessInput).
pub fn builder() -> crate::input::update_access_input::Builder {
crate::input::update_access_input::Builder::default()
}
}
/// See [`UpdateAgreementInput`](crate::input::UpdateAgreementInput).
pub mod update_agreement_input {
/// A builder for [`UpdateAgreementInput`](crate::input::UpdateAgreementInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) agreement_id: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<crate::model::AgreementStatusType>,
pub(crate) local_profile_id: std::option::Option<std::string::String>,
pub(crate) partner_profile_id: std::option::Option<std::string::String>,
pub(crate) base_directory: std::option::Option<std::string::String>,
pub(crate) access_role: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(mut self, input: impl Into<std::string::String>) -> Self {
self.agreement_id = Some(input.into());
self
}
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn set_agreement_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.agreement_id = input;
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>To replace the existing description, provide a short description for the agreement. </p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>To replace the existing description, provide a short description for the agreement. </p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// <p>You can update the status for the agreement, either activating an inactive agreement or the reverse.</p>
pub fn status(mut self, input: crate::model::AgreementStatusType) -> Self {
self.status = Some(input);
self
}
/// <p>You can update the status for the agreement, either activating an inactive agreement or the reverse.</p>
pub fn set_status(
mut self,
input: std::option::Option<crate::model::AgreementStatusType>,
) -> Self {
self.status = input;
self
}
/// <p>A unique identifier for the AS2 local profile.</p>
/// <p>To change the local profile identifier, provide a new value here.</p>
pub fn local_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.local_profile_id = Some(input.into());
self
}
/// <p>A unique identifier for the AS2 local profile.</p>
/// <p>To change the local profile identifier, provide a new value here.</p>
pub fn set_local_profile_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.local_profile_id = input;
self
}
/// <p>A unique identifier for the partner profile. To change the partner profile identifier, provide a new value here.</p>
pub fn partner_profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.partner_profile_id = Some(input.into());
self
}
/// <p>A unique identifier for the partner profile. To change the partner profile identifier, provide a new value here.</p>
pub fn set_partner_profile_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.partner_profile_id = input;
self
}
/// <p>To change the landing directory (folder) for files that are transferred, provide the bucket folder that you want to use; for example, <code>/<i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i> </code>.</p>
pub fn base_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.base_directory = Some(input.into());
self
}
/// <p>To change the landing directory (folder) for files that are transferred, provide the bucket folder that you want to use; for example, <code>/<i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i> </code>.</p>
pub fn set_base_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.base_directory = input;
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(mut self, input: impl Into<std::string::String>) -> Self {
self.access_role = Some(input.into());
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn set_access_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.access_role = input;
self
}
/// Consumes the builder and constructs a [`UpdateAgreementInput`](crate::input::UpdateAgreementInput).
pub fn build(
self,
) -> Result<crate::input::UpdateAgreementInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateAgreementInput {
agreement_id: self.agreement_id,
server_id: self.server_id,
description: self.description,
status: self.status,
local_profile_id: self.local_profile_id,
partner_profile_id: self.partner_profile_id,
base_directory: self.base_directory,
access_role: self.access_role,
})
}
}
}
impl UpdateAgreementInput {
/// Consumes the builder and constructs an Operation<[`UpdateAgreement`](crate::operation::UpdateAgreement)>
#[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::UpdateAgreement,
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::UpdateAgreementInput,
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::UpdateAgreementInput,
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"),
"TransferService.UpdateAgreement",
);
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_agreement(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateAgreement::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateAgreement",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateAgreementInput`](crate::input::UpdateAgreementInput).
pub fn builder() -> crate::input::update_agreement_input::Builder {
crate::input::update_agreement_input::Builder::default()
}
}
/// See [`UpdateCertificateInput`](crate::input::UpdateCertificateInput).
pub mod update_certificate_input {
/// A builder for [`UpdateCertificateInput`](crate::input::UpdateCertificateInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) certificate_id: std::option::Option<std::string::String>,
pub(crate) active_date: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) inactive_date: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the certificate object that you are updating.</p>
pub fn certificate_id(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate_id = Some(input.into());
self
}
/// <p>The identifier of the certificate object that you are updating.</p>
pub fn set_certificate_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.certificate_id = input;
self
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn active_date(mut self, input: aws_smithy_types::DateTime) -> Self {
self.active_date = Some(input);
self
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn set_active_date(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.active_date = input;
self
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn inactive_date(mut self, input: aws_smithy_types::DateTime) -> Self {
self.inactive_date = Some(input);
self
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn set_inactive_date(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.inactive_date = input;
self
}
/// <p>A short description to help identify the certificate.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>A short description to help identify the certificate.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Consumes the builder and constructs a [`UpdateCertificateInput`](crate::input::UpdateCertificateInput).
pub fn build(
self,
) -> Result<
crate::input::UpdateCertificateInput,
aws_smithy_http::operation::error::BuildError,
> {
Ok(crate::input::UpdateCertificateInput {
certificate_id: self.certificate_id,
active_date: self.active_date,
inactive_date: self.inactive_date,
description: self.description,
})
}
}
}
impl UpdateCertificateInput {
/// Consumes the builder and constructs an Operation<[`UpdateCertificate`](crate::operation::UpdateCertificate)>
#[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::UpdateCertificate,
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::UpdateCertificateInput,
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::UpdateCertificateInput,
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"),
"TransferService.UpdateCertificate",
);
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_certificate(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateCertificate::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateCertificate",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateCertificateInput`](crate::input::UpdateCertificateInput).
pub fn builder() -> crate::input::update_certificate_input::Builder {
crate::input::update_certificate_input::Builder::default()
}
}
/// See [`UpdateConnectorInput`](crate::input::UpdateConnectorInput).
pub mod update_connector_input {
/// A builder for [`UpdateConnectorInput`](crate::input::UpdateConnectorInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) connector_id: std::option::Option<std::string::String>,
pub(crate) url: std::option::Option<std::string::String>,
pub(crate) as2_config: std::option::Option<crate::model::As2ConnectorConfig>,
pub(crate) access_role: std::option::Option<std::string::String>,
pub(crate) logging_role: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(mut self, input: impl Into<std::string::String>) -> Self {
self.connector_id = Some(input.into());
self
}
/// <p>The unique identifier for the connector.</p>
pub fn set_connector_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.connector_id = input;
self
}
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn url(mut self, input: impl Into<std::string::String>) -> Self {
self.url = Some(input.into());
self
}
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn set_url(mut self, input: std::option::Option<std::string::String>) -> Self {
self.url = input;
self
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn as2_config(mut self, input: crate::model::As2ConnectorConfig) -> Self {
self.as2_config = Some(input);
self
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn set_as2_config(
mut self,
input: std::option::Option<crate::model::As2ConnectorConfig>,
) -> Self {
self.as2_config = input;
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(mut self, input: impl Into<std::string::String>) -> Self {
self.access_role = Some(input.into());
self
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn set_access_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.access_role = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn logging_role(mut self, input: impl Into<std::string::String>) -> Self {
self.logging_role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn set_logging_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.logging_role = input;
self
}
/// Consumes the builder and constructs a [`UpdateConnectorInput`](crate::input::UpdateConnectorInput).
pub fn build(
self,
) -> Result<crate::input::UpdateConnectorInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateConnectorInput {
connector_id: self.connector_id,
url: self.url,
as2_config: self.as2_config,
access_role: self.access_role,
logging_role: self.logging_role,
})
}
}
}
impl UpdateConnectorInput {
/// Consumes the builder and constructs an Operation<[`UpdateConnector`](crate::operation::UpdateConnector)>
#[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::UpdateConnector,
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::UpdateConnectorInput,
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::UpdateConnectorInput,
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"),
"TransferService.UpdateConnector",
);
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_connector(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateConnector::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateConnector",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateConnectorInput`](crate::input::UpdateConnectorInput).
pub fn builder() -> crate::input::update_connector_input::Builder {
crate::input::update_connector_input::Builder::default()
}
}
/// See [`UpdateHostKeyInput`](crate::input::UpdateHostKeyInput).
pub mod update_host_key_input {
/// A builder for [`UpdateHostKeyInput`](crate::input::UpdateHostKeyInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) host_key_id: std::option::Option<std::string::String>,
pub(crate) description: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The identifier of the server that contains the host key that you are updating.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>The identifier of the server that contains the host key that you are updating.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>The identifier of the host key that you are updating.</p>
pub fn host_key_id(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key_id = Some(input.into());
self
}
/// <p>The identifier of the host key that you are updating.</p>
pub fn set_host_key_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_key_id = input;
self
}
/// <p>An updated description for the host key.</p>
pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
self.description = Some(input.into());
self
}
/// <p>An updated description for the host key.</p>
pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
self.description = input;
self
}
/// Consumes the builder and constructs a [`UpdateHostKeyInput`](crate::input::UpdateHostKeyInput).
pub fn build(
self,
) -> Result<crate::input::UpdateHostKeyInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateHostKeyInput {
server_id: self.server_id,
host_key_id: self.host_key_id,
description: self.description,
})
}
}
}
impl UpdateHostKeyInput {
/// Consumes the builder and constructs an Operation<[`UpdateHostKey`](crate::operation::UpdateHostKey)>
#[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::UpdateHostKey,
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::UpdateHostKeyInput,
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::UpdateHostKeyInput,
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"),
"TransferService.UpdateHostKey",
);
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_host_key(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateHostKey::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateHostKey",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateHostKeyInput`](crate::input::UpdateHostKeyInput).
pub fn builder() -> crate::input::update_host_key_input::Builder {
crate::input::update_host_key_input::Builder::default()
}
}
/// See [`UpdateProfileInput`](crate::input::UpdateProfileInput).
pub mod update_profile_input {
/// A builder for [`UpdateProfileInput`](crate::input::UpdateProfileInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) profile_id: std::option::Option<std::string::String>,
pub(crate) certificate_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl Builder {
/// <p>The identifier of the profile object that you are updating.</p>
pub fn profile_id(mut self, input: impl Into<std::string::String>) -> Self {
self.profile_id = Some(input.into());
self
}
/// <p>The identifier of the profile object that you are updating.</p>
pub fn set_profile_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.profile_id = input;
self
}
/// Appends an item to `certificate_ids`.
///
/// To override the contents of this collection use [`set_certificate_ids`](Self::set_certificate_ids).
///
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_ids(mut self, input: impl Into<std::string::String>) -> Self {
let mut v = self.certificate_ids.unwrap_or_default();
v.push(input.into());
self.certificate_ids = Some(v);
self
}
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn set_certificate_ids(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.certificate_ids = input;
self
}
/// Consumes the builder and constructs a [`UpdateProfileInput`](crate::input::UpdateProfileInput).
pub fn build(
self,
) -> Result<crate::input::UpdateProfileInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateProfileInput {
profile_id: self.profile_id,
certificate_ids: self.certificate_ids,
})
}
}
}
impl UpdateProfileInput {
/// Consumes the builder and constructs an Operation<[`UpdateProfile`](crate::operation::UpdateProfile)>
#[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::UpdateProfile,
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::UpdateProfileInput,
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::UpdateProfileInput,
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"),
"TransferService.UpdateProfile",
);
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_profile(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateProfile::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateProfile",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateProfileInput`](crate::input::UpdateProfileInput).
pub fn builder() -> crate::input::update_profile_input::Builder {
crate::input::update_profile_input::Builder::default()
}
}
/// See [`UpdateServerInput`](crate::input::UpdateServerInput).
pub mod update_server_input {
/// A builder for [`UpdateServerInput`](crate::input::UpdateServerInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) certificate: std::option::Option<std::string::String>,
pub(crate) protocol_details: std::option::Option<crate::model::ProtocolDetails>,
pub(crate) endpoint_details: std::option::Option<crate::model::EndpointDetails>,
pub(crate) endpoint_type: std::option::Option<crate::model::EndpointType>,
pub(crate) host_key: std::option::Option<std::string::String>,
pub(crate) identity_provider_details:
std::option::Option<crate::model::IdentityProviderDetails>,
pub(crate) logging_role: std::option::Option<std::string::String>,
pub(crate) post_authentication_login_banner: std::option::Option<std::string::String>,
pub(crate) pre_authentication_login_banner: std::option::Option<std::string::String>,
pub(crate) protocols: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
pub(crate) security_policy_name: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) workflow_details: std::option::Option<crate::model::WorkflowDetails>,
}
impl Builder {
/// <p>The Amazon Resource Name (ARN) of the Amazon Web ServicesCertificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn certificate(mut self, input: impl Into<std::string::String>) -> Self {
self.certificate = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Amazon Web ServicesCertificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn set_certificate(mut self, input: std::option::Option<std::string::String>) -> Self {
self.certificate = input;
self
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn protocol_details(mut self, input: crate::model::ProtocolDetails) -> Self {
self.protocol_details = Some(input);
self
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn set_protocol_details(
mut self,
input: std::option::Option<crate::model::ProtocolDetails>,
) -> Self {
self.protocol_details = input;
self
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn endpoint_details(mut self, input: crate::model::EndpointDetails) -> Self {
self.endpoint_details = Some(input);
self
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn set_endpoint_details(
mut self,
input: std::option::Option<crate::model::EndpointDetails>,
) -> Self {
self.endpoint_details = input;
self
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn endpoint_type(mut self, input: crate::model::EndpointType) -> Self {
self.endpoint_type = Some(input);
self
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn set_endpoint_type(
mut self,
input: std::option::Option<crate::model::EndpointType>,
) -> Self {
self.endpoint_type = input;
self
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn host_key(mut self, input: impl Into<std::string::String>) -> Self {
self.host_key = Some(input.into());
self
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn set_host_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.host_key = input;
self
}
/// <p>An array containing all of the information required to call a customer's authentication API method.</p>
pub fn identity_provider_details(
mut self,
input: crate::model::IdentityProviderDetails,
) -> Self {
self.identity_provider_details = Some(input);
self
}
/// <p>An array containing all of the information required to call a customer's authentication API method.</p>
pub fn set_identity_provider_details(
mut self,
input: std::option::Option<crate::model::IdentityProviderDetails>,
) -> Self {
self.identity_provider_details = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn logging_role(mut self, input: impl Into<std::string::String>) -> Self {
self.logging_role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn set_logging_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.logging_role = input;
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn post_authentication_login_banner(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.post_authentication_login_banner = Some(input.into());
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn set_post_authentication_login_banner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.post_authentication_login_banner = input;
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn pre_authentication_login_banner(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.pre_authentication_login_banner = Some(input.into());
self
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn set_pre_authentication_login_banner(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.pre_authentication_login_banner = input;
self
}
/// Appends an item to `protocols`.
///
/// To override the contents of this collection use [`set_protocols`](Self::set_protocols).
///
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn protocols(mut self, input: crate::model::Protocol) -> Self {
let mut v = self.protocols.unwrap_or_default();
v.push(input);
self.protocols = Some(v);
self
}
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn set_protocols(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
) -> Self {
self.protocols = input;
self
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(mut self, input: impl Into<std::string::String>) -> Self {
self.security_policy_name = Some(input.into());
self
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn set_security_policy_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.security_policy_name = input;
self
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
/// <p>To remove an associated workflow from a server, you can provide an empty <code>OnUpload</code> object, as in the following example.</p>
/// <p> <code>aws transfer update-server --server-id s-01234567890abcdef --workflow-details '{"OnUpload":[]}'</code> </p>
pub fn workflow_details(mut self, input: crate::model::WorkflowDetails) -> Self {
self.workflow_details = Some(input);
self
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
/// <p>To remove an associated workflow from a server, you can provide an empty <code>OnUpload</code> object, as in the following example.</p>
/// <p> <code>aws transfer update-server --server-id s-01234567890abcdef --workflow-details '{"OnUpload":[]}'</code> </p>
pub fn set_workflow_details(
mut self,
input: std::option::Option<crate::model::WorkflowDetails>,
) -> Self {
self.workflow_details = input;
self
}
/// Consumes the builder and constructs a [`UpdateServerInput`](crate::input::UpdateServerInput).
pub fn build(
self,
) -> Result<crate::input::UpdateServerInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateServerInput {
certificate: self.certificate,
protocol_details: self.protocol_details,
endpoint_details: self.endpoint_details,
endpoint_type: self.endpoint_type,
host_key: self.host_key,
identity_provider_details: self.identity_provider_details,
logging_role: self.logging_role,
post_authentication_login_banner: self.post_authentication_login_banner,
pre_authentication_login_banner: self.pre_authentication_login_banner,
protocols: self.protocols,
security_policy_name: self.security_policy_name,
server_id: self.server_id,
workflow_details: self.workflow_details,
})
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("certificate", &self.certificate);
formatter.field("protocol_details", &self.protocol_details);
formatter.field("endpoint_details", &self.endpoint_details);
formatter.field("endpoint_type", &self.endpoint_type);
formatter.field("host_key", &"*** Sensitive Data Redacted ***");
formatter.field("identity_provider_details", &self.identity_provider_details);
formatter.field("logging_role", &self.logging_role);
formatter.field(
"post_authentication_login_banner",
&self.post_authentication_login_banner,
);
formatter.field(
"pre_authentication_login_banner",
&self.pre_authentication_login_banner,
);
formatter.field("protocols", &self.protocols);
formatter.field("security_policy_name", &self.security_policy_name);
formatter.field("server_id", &self.server_id);
formatter.field("workflow_details", &self.workflow_details);
formatter.finish()
}
}
}
impl UpdateServerInput {
/// Consumes the builder and constructs an Operation<[`UpdateServer`](crate::operation::UpdateServer)>
#[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::UpdateServer,
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::UpdateServerInput,
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::UpdateServerInput,
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"),
"TransferService.UpdateServer",
);
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_server(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateServer::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateServer",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateServerInput`](crate::input::UpdateServerInput).
pub fn builder() -> crate::input::update_server_input::Builder {
crate::input::update_server_input::Builder::default()
}
}
/// See [`UpdateUserInput`](crate::input::UpdateUserInput).
pub mod update_user_input {
/// A builder for [`UpdateUserInput`](crate::input::UpdateUserInput).
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) home_directory: std::option::Option<std::string::String>,
pub(crate) home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
pub(crate) home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
pub(crate) policy: std::option::Option<std::string::String>,
pub(crate) posix_profile: std::option::Option<crate::model::PosixProfile>,
pub(crate) role: std::option::Option<std::string::String>,
pub(crate) server_id: std::option::Option<std::string::String>,
pub(crate) user_name: std::option::Option<std::string::String>,
}
impl Builder {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(mut self, input: impl Into<std::string::String>) -> Self {
self.home_directory = Some(input.into());
self
}
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn set_home_directory(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.home_directory = input;
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(mut self, input: crate::model::HomeDirectoryType) -> Self {
self.home_directory_type = Some(input);
self
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn set_home_directory_type(
mut self,
input: std::option::Option<crate::model::HomeDirectoryType>,
) -> Self {
self.home_directory_type = input;
self
}
/// Appends an item to `home_directory_mappings`.
///
/// To override the contents of this collection use [`set_home_directory_mappings`](Self::set_home_directory_mappings).
///
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to '/' and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
mut self,
input: crate::model::HomeDirectoryMapEntry,
) -> Self {
let mut v = self.home_directory_mappings.unwrap_or_default();
v.push(input);
self.home_directory_mappings = Some(v);
self
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to '/' and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn set_home_directory_mappings(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
) -> Self {
self.home_directory_mappings = input;
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy">Creating a session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(mut self, input: impl Into<std::string::String>) -> Self {
self.policy = Some(input.into());
self
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy">Creating a session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn set_policy(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy = input;
self
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon Elastic File Systems (Amazon EFS). The POSIX permissions that are set on files and directories in your file system determines the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(mut self, input: crate::model::PosixProfile) -> Self {
self.posix_profile = Some(input);
self
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon Elastic File Systems (Amazon EFS). The POSIX permissions that are set on files and directories in your file system determines the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn set_posix_profile(
mut self,
input: std::option::Option<crate::model::PosixProfile>,
) -> Self {
self.posix_profile = input;
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(mut self, input: impl Into<std::string::String>) -> Self {
self.role = Some(input.into());
self
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn set_role(mut self, input: std::option::Option<std::string::String>) -> Self {
self.role = input;
self
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn server_id(mut self, input: impl Into<std::string::String>) -> Self {
self.server_id = Some(input.into());
self
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn set_server_id(mut self, input: std::option::Option<std::string::String>) -> Self {
self.server_id = input;
self
}
/// <p>A unique string that identifies a user and is associated with a server as specified by the <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn user_name(mut self, input: impl Into<std::string::String>) -> Self {
self.user_name = Some(input.into());
self
}
/// <p>A unique string that identifies a user and is associated with a server as specified by the <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn set_user_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.user_name = input;
self
}
/// Consumes the builder and constructs a [`UpdateUserInput`](crate::input::UpdateUserInput).
pub fn build(
self,
) -> Result<crate::input::UpdateUserInput, aws_smithy_http::operation::error::BuildError>
{
Ok(crate::input::UpdateUserInput {
home_directory: self.home_directory,
home_directory_type: self.home_directory_type,
home_directory_mappings: self.home_directory_mappings,
policy: self.policy,
posix_profile: self.posix_profile,
role: self.role,
server_id: self.server_id,
user_name: self.user_name,
})
}
}
}
impl UpdateUserInput {
/// Consumes the builder and constructs an Operation<[`UpdateUser`](crate::operation::UpdateUser)>
#[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::UpdateUser,
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::UpdateUserInput,
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::UpdateUserInput,
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"),
"TransferService.UpdateUser",
);
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_user(&self)?,
);
if let Some(content_length) = body.content_length() {
request = aws_smithy_http::header::set_request_header_if_absent(
request,
http::header::CONTENT_LENGTH,
content_length,
);
}
let request = request.body(body).expect("should be valid request");
let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = aws_http::user_agent::AwsUserAgent::new_from_environment(
aws_types::os_shim_internal::Env::real(),
crate::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = aws_sig_auth::signer::OperationSigningConfig::default_config();
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = aws_smithy_http::operation::Operation::new(
request,
crate::operation::UpdateUser::new(),
)
.with_metadata(aws_smithy_http::operation::Metadata::new(
"UpdateUser",
"transfer",
));
let op = op.with_retry_classifier(aws_http::retry::AwsResponseRetryClassifier::new());
Ok(op)
}
/// Creates a new builder-style object to manufacture [`UpdateUserInput`](crate::input::UpdateUserInput).
pub fn builder() -> crate::input::update_user_input::Builder {
crate::input::update_user_input::Builder::default()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateUserInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
#[doc(hidden)]
pub home_directory: std::option::Option<std::string::String>,
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
#[doc(hidden)]
pub home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to '/' and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
#[doc(hidden)]
pub home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy">Creating a session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
#[doc(hidden)]
pub policy: std::option::Option<std::string::String>,
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon Elastic File Systems (Amazon EFS). The POSIX permissions that are set on files and directories in your file system determines the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
#[doc(hidden)]
pub posix_profile: std::option::Option<crate::model::PosixProfile>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique string that identifies a user and is associated with a server as specified by the <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl UpdateUserInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(&self) -> std::option::Option<&str> {
self.home_directory.as_deref()
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(&self) -> std::option::Option<&crate::model::HomeDirectoryType> {
self.home_directory_type.as_ref()
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to '/' and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
&self,
) -> std::option::Option<&[crate::model::HomeDirectoryMapEntry]> {
self.home_directory_mappings.as_deref()
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy">Creating a session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(&self) -> std::option::Option<&str> {
self.policy.as_deref()
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon Elastic File Systems (Amazon EFS). The POSIX permissions that are set on files and directories in your file system determines the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(&self) -> std::option::Option<&crate::model::PosixProfile> {
self.posix_profile.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique string that identifies a user and is associated with a server as specified by the <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateServerInput {
/// <p>The Amazon Resource Name (ARN) of the Amazon Web ServicesCertificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
#[doc(hidden)]
pub certificate: std::option::Option<std::string::String>,
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
#[doc(hidden)]
pub protocol_details: std::option::Option<crate::model::ProtocolDetails>,
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
#[doc(hidden)]
pub endpoint_details: std::option::Option<crate::model::EndpointDetails>,
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
#[doc(hidden)]
pub endpoint_type: std::option::Option<crate::model::EndpointType>,
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
#[doc(hidden)]
pub host_key: std::option::Option<std::string::String>,
/// <p>An array containing all of the information required to call a customer's authentication API method.</p>
#[doc(hidden)]
pub identity_provider_details: std::option::Option<crate::model::IdentityProviderDetails>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
#[doc(hidden)]
pub logging_role: std::option::Option<std::string::String>,
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
#[doc(hidden)]
pub post_authentication_login_banner: std::option::Option<std::string::String>,
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
#[doc(hidden)]
pub pre_authentication_login_banner: std::option::Option<std::string::String>,
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
#[doc(hidden)]
pub protocols: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
/// <p>Specifies the name of the security policy that is attached to the server.</p>
#[doc(hidden)]
pub security_policy_name: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
/// <p>To remove an associated workflow from a server, you can provide an empty <code>OnUpload</code> object, as in the following example.</p>
/// <p> <code>aws transfer update-server --server-id s-01234567890abcdef --workflow-details '{"OnUpload":[]}'</code> </p>
#[doc(hidden)]
pub workflow_details: std::option::Option<crate::model::WorkflowDetails>,
}
impl UpdateServerInput {
/// <p>The Amazon Resource Name (ARN) of the Amazon Web ServicesCertificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i> Amazon Web ServicesCertificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn certificate(&self) -> std::option::Option<&str> {
self.certificate.as_deref()
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn protocol_details(&self) -> std::option::Option<&crate::model::ProtocolDetails> {
self.protocol_details.as_ref()
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn endpoint_details(&self) -> std::option::Option<&crate::model::EndpointDetails> {
self.endpoint_details.as_ref()
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Servicesaccount on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn endpoint_type(&self) -> std::option::Option<&crate::model::EndpointType> {
self.endpoint_type.as_ref()
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn host_key(&self) -> std::option::Option<&str> {
self.host_key.as_deref()
}
/// <p>An array containing all of the information required to call a customer's authentication API method.</p>
pub fn identity_provider_details(
&self,
) -> std::option::Option<&crate::model::IdentityProviderDetails> {
self.identity_provider_details.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn logging_role(&self) -> std::option::Option<&str> {
self.logging_role.as_deref()
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn post_authentication_login_banner(&self) -> std::option::Option<&str> {
self.post_authentication_login_banner.as_deref()
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn pre_authentication_login_banner(&self) -> std::option::Option<&str> {
self.pre_authentication_login_banner.as_deref()
}
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn protocols(&self) -> std::option::Option<&[crate::model::Protocol]> {
self.protocols.as_deref()
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(&self) -> std::option::Option<&str> {
self.security_policy_name.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance that the user account is assigned to.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
/// <p>To remove an associated workflow from a server, you can provide an empty <code>OnUpload</code> object, as in the following example.</p>
/// <p> <code>aws transfer update-server --server-id s-01234567890abcdef --workflow-details '{"OnUpload":[]}'</code> </p>
pub fn workflow_details(&self) -> std::option::Option<&crate::model::WorkflowDetails> {
self.workflow_details.as_ref()
}
}
impl std::fmt::Debug for UpdateServerInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("UpdateServerInput");
formatter.field("certificate", &self.certificate);
formatter.field("protocol_details", &self.protocol_details);
formatter.field("endpoint_details", &self.endpoint_details);
formatter.field("endpoint_type", &self.endpoint_type);
formatter.field("host_key", &"*** Sensitive Data Redacted ***");
formatter.field("identity_provider_details", &self.identity_provider_details);
formatter.field("logging_role", &self.logging_role);
formatter.field(
"post_authentication_login_banner",
&self.post_authentication_login_banner,
);
formatter.field(
"pre_authentication_login_banner",
&self.pre_authentication_login_banner,
);
formatter.field("protocols", &self.protocols);
formatter.field("security_policy_name", &self.security_policy_name);
formatter.field("server_id", &self.server_id);
formatter.field("workflow_details", &self.workflow_details);
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateProfileInput {
/// <p>The identifier of the profile object that you are updating.</p>
#[doc(hidden)]
pub profile_id: std::option::Option<std::string::String>,
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
#[doc(hidden)]
pub certificate_ids: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UpdateProfileInput {
/// <p>The identifier of the profile object that you are updating.</p>
pub fn profile_id(&self) -> std::option::Option<&str> {
self.profile_id.as_deref()
}
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_ids(&self) -> std::option::Option<&[std::string::String]> {
self.certificate_ids.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are updating.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The identifier of the host key that you are updating.</p>
#[doc(hidden)]
pub host_key_id: std::option::Option<std::string::String>,
/// <p>An updated description for the host key.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
}
impl UpdateHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are updating.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The identifier of the host key that you are updating.</p>
pub fn host_key_id(&self) -> std::option::Option<&str> {
self.host_key_id.as_deref()
}
/// <p>An updated description for the host key.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateConnectorInput {
/// <p>The unique identifier for the connector.</p>
#[doc(hidden)]
pub connector_id: std::option::Option<std::string::String>,
/// <p>The URL of the partner's AS2 endpoint.</p>
#[doc(hidden)]
pub url: std::option::Option<std::string::String>,
/// <p>A structure that contains the parameters for a connector object.</p>
#[doc(hidden)]
pub as2_config: std::option::Option<crate::model::As2ConnectorConfig>,
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
#[doc(hidden)]
pub access_role: std::option::Option<std::string::String>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
#[doc(hidden)]
pub logging_role: std::option::Option<std::string::String>,
}
impl UpdateConnectorInput {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(&self) -> std::option::Option<&str> {
self.connector_id.as_deref()
}
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn url(&self) -> std::option::Option<&str> {
self.url.as_deref()
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn as2_config(&self) -> std::option::Option<&crate::model::As2ConnectorConfig> {
self.as2_config.as_ref()
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(&self) -> std::option::Option<&str> {
self.access_role.as_deref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn logging_role(&self) -> std::option::Option<&str> {
self.logging_role.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateCertificateInput {
/// <p>The identifier of the certificate object that you are updating.</p>
#[doc(hidden)]
pub certificate_id: std::option::Option<std::string::String>,
/// <p>An optional date that specifies when the certificate becomes active.</p>
#[doc(hidden)]
pub active_date: std::option::Option<aws_smithy_types::DateTime>,
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
#[doc(hidden)]
pub inactive_date: std::option::Option<aws_smithy_types::DateTime>,
/// <p>A short description to help identify the certificate.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
}
impl UpdateCertificateInput {
/// <p>The identifier of the certificate object that you are updating.</p>
pub fn certificate_id(&self) -> std::option::Option<&str> {
self.certificate_id.as_deref()
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn active_date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.active_date.as_ref()
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn inactive_date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.inactive_date.as_ref()
}
/// <p>A short description to help identify the certificate.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
#[doc(hidden)]
pub agreement_id: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>To replace the existing description, provide a short description for the agreement. </p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>You can update the status for the agreement, either activating an inactive agreement or the reverse.</p>
#[doc(hidden)]
pub status: std::option::Option<crate::model::AgreementStatusType>,
/// <p>A unique identifier for the AS2 local profile.</p>
/// <p>To change the local profile identifier, provide a new value here.</p>
#[doc(hidden)]
pub local_profile_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the partner profile. To change the partner profile identifier, provide a new value here.</p>
#[doc(hidden)]
pub partner_profile_id: std::option::Option<std::string::String>,
/// <p>To change the landing directory (folder) for files that are transferred, provide the bucket folder that you want to use; for example, <code>/<i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i> </code>.</p>
#[doc(hidden)]
pub base_directory: std::option::Option<std::string::String>,
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
#[doc(hidden)]
pub access_role: std::option::Option<std::string::String>,
}
impl UpdateAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(&self) -> std::option::Option<&str> {
self.agreement_id.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>To replace the existing description, provide a short description for the agreement. </p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>You can update the status for the agreement, either activating an inactive agreement or the reverse.</p>
pub fn status(&self) -> std::option::Option<&crate::model::AgreementStatusType> {
self.status.as_ref()
}
/// <p>A unique identifier for the AS2 local profile.</p>
/// <p>To change the local profile identifier, provide a new value here.</p>
pub fn local_profile_id(&self) -> std::option::Option<&str> {
self.local_profile_id.as_deref()
}
/// <p>A unique identifier for the partner profile. To change the partner profile identifier, provide a new value here.</p>
pub fn partner_profile_id(&self) -> std::option::Option<&str> {
self.partner_profile_id.as_deref()
}
/// <p>To change the landing directory (folder) for files that are transferred, provide the bucket folder that you want to use; for example, <code>/<i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i> </code>.</p>
pub fn base_directory(&self) -> std::option::Option<&str> {
self.base_directory.as_deref()
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(&self) -> std::option::Option<&str> {
self.access_role.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAccessInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
#[doc(hidden)]
pub home_directory: std::option::Option<std::string::String>,
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
#[doc(hidden)]
pub home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
#[doc(hidden)]
pub home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web ServicesSecurity Token Service API Reference</i>.</p>
/// </note>
#[doc(hidden)]
pub policy: std::option::Option<std::string::String>,
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
#[doc(hidden)]
pub posix_profile: std::option::Option<crate::model::PosixProfile>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
#[doc(hidden)]
pub external_id: std::option::Option<std::string::String>,
}
impl UpdateAccessInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(&self) -> std::option::Option<&str> {
self.home_directory.as_deref()
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(&self) -> std::option::Option<&crate::model::HomeDirectoryType> {
self.home_directory_type.as_ref()
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
&self,
) -> std::option::Option<&[crate::model::HomeDirectoryMapEntry]> {
self.home_directory_mappings.as_deref()
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web ServicesSecurity Token Service API Reference</i>.</p>
/// </note>
pub fn policy(&self) -> std::option::Option<&str> {
self.policy.as_deref()
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(&self) -> std::option::Option<&crate::model::PosixProfile> {
self.posix_profile.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(&self) -> std::option::Option<&str> {
self.external_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceInput {
/// <p>The value of the resource that will have the tag removed. An Amazon Resource Name (ARN) is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
/// <p>TagKeys are key-value pairs assigned to ARNs that can be used to group and search for resources by type. This metadata can be attached to resources for any purpose.</p>
#[doc(hidden)]
pub tag_keys: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl UntagResourceInput {
/// <p>The value of the resource that will have the tag removed. An Amazon Resource Name (ARN) is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
/// <p>TagKeys are key-value pairs assigned to ARNs that can be used to group and search for resources by type. This metadata can be attached to resources for any purpose.</p>
pub fn tag_keys(&self) -> std::option::Option<&[std::string::String]> {
self.tag_keys.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TestIdentityProviderInput {
/// <p>A system-assigned identifier for a specific server. That server's user authentication method is tested with a user name and password.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The type of file transfer protocol to be tested.</p>
/// <p>The available protocols are:</p>
/// <ul>
/// <li> <p>Secure Shell (SSH) File Transfer Protocol (SFTP)</p> </li>
/// <li> <p>File Transfer Protocol Secure (FTPS)</p> </li>
/// <li> <p>File Transfer Protocol (FTP)</p> </li>
/// </ul>
#[doc(hidden)]
pub server_protocol: std::option::Option<crate::model::Protocol>,
/// <p>The source IP address of the user account to be tested.</p>
#[doc(hidden)]
pub source_ip: std::option::Option<std::string::String>,
/// <p>The name of the user account to be tested.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
/// <p>The password of the user account to be tested.</p>
#[doc(hidden)]
pub user_password: std::option::Option<std::string::String>,
}
impl TestIdentityProviderInput {
/// <p>A system-assigned identifier for a specific server. That server's user authentication method is tested with a user name and password.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The type of file transfer protocol to be tested.</p>
/// <p>The available protocols are:</p>
/// <ul>
/// <li> <p>Secure Shell (SSH) File Transfer Protocol (SFTP)</p> </li>
/// <li> <p>File Transfer Protocol Secure (FTPS)</p> </li>
/// <li> <p>File Transfer Protocol (FTP)</p> </li>
/// </ul>
pub fn server_protocol(&self) -> std::option::Option<&crate::model::Protocol> {
self.server_protocol.as_ref()
}
/// <p>The source IP address of the user account to be tested.</p>
pub fn source_ip(&self) -> std::option::Option<&str> {
self.source_ip.as_deref()
}
/// <p>The name of the user account to be tested.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
/// <p>The password of the user account to be tested.</p>
pub fn user_password(&self) -> std::option::Option<&str> {
self.user_password.as_deref()
}
}
impl std::fmt::Debug for TestIdentityProviderInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("TestIdentityProviderInput");
formatter.field("server_id", &self.server_id);
formatter.field("server_protocol", &self.server_protocol);
formatter.field("source_ip", &self.source_ip);
formatter.field("user_name", &self.user_name);
formatter.field("user_password", &"*** Sensitive Data Redacted ***");
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagResourceInput {
/// <p>An Amazon Resource Name (ARN) for a specific Amazon Web Services resource, such as a server, user, or role.</p>
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
/// <p>Key-value pairs assigned to ARNs that you can use to group and search for resources by type. You can attach this metadata to user accounts for any purpose.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl TagResourceInput {
/// <p>An Amazon Resource Name (ARN) for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
/// <p>Key-value pairs assigned to ARNs that you can use to group and search for resources by type. You can attach this metadata to user accounts for any purpose.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopServerInput {
/// <p>A system-assigned unique identifier for a server that you stopped.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl StopServerInput {
/// <p>A system-assigned unique identifier for a server that you stopped.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartServerInput {
/// <p>A system-assigned unique identifier for a server that you start.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl StartServerInput {
/// <p>A system-assigned unique identifier for a server that you start.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartFileTransferInput {
/// <p>The unique identifier for the connector. </p>
#[doc(hidden)]
pub connector_id: std::option::Option<std::string::String>,
/// <p>An array of strings. Each string represents the absolute path for one outbound file transfer. For example, <code> <i>DOC-EXAMPLE-BUCKET</i>/<i>myfile.txt</i> </code>. </p>
#[doc(hidden)]
pub send_file_paths: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl StartFileTransferInput {
/// <p>The unique identifier for the connector. </p>
pub fn connector_id(&self) -> std::option::Option<&str> {
self.connector_id.as_deref()
}
/// <p>An array of strings. Each string represents the absolute path for one outbound file transfer. For example, <code> <i>DOC-EXAMPLE-BUCKET</i>/<i>myfile.txt</i> </code>. </p>
pub fn send_file_paths(&self) -> std::option::Option<&[std::string::String]> {
self.send_file_paths.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SendWorkflowStepStateInput {
/// <p>A unique identifier for the workflow.</p>
#[doc(hidden)]
pub workflow_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the execution of a workflow.</p>
#[doc(hidden)]
pub execution_id: std::option::Option<std::string::String>,
/// <p>Used to distinguish between multiple callbacks for multiple Lambda steps within the same execution.</p>
#[doc(hidden)]
pub token: std::option::Option<std::string::String>,
/// <p>Indicates whether the specified step succeeded or failed.</p>
#[doc(hidden)]
pub status: std::option::Option<crate::model::CustomStepStatus>,
}
impl SendWorkflowStepStateInput {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(&self) -> std::option::Option<&str> {
self.workflow_id.as_deref()
}
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn execution_id(&self) -> std::option::Option<&str> {
self.execution_id.as_deref()
}
/// <p>Used to distinguish between multiple callbacks for multiple Lambda steps within the same execution.</p>
pub fn token(&self) -> std::option::Option<&str> {
self.token.as_deref()
}
/// <p>Indicates whether the specified step succeeded or failed.</p>
pub fn status(&self) -> std::option::Option<&crate::model::CustomStepStatus> {
self.status.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListWorkflowsInput {
/// <p>Specifies the maximum number of workflows to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p> <code>ListWorkflows</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional workflows.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListWorkflowsInput {
/// <p>Specifies the maximum number of workflows to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p> <code>ListWorkflows</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional workflows.</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 ListUsersInput {
/// <p>Specifies the number of users to return as a response to the <code>ListUsers</code> request.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you can get additional results from the <code>ListUsers</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional users.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl ListUsersInput {
/// <p>Specifies the number of users to return as a response to the <code>ListUsers</code> request.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you can get additional results from the <code>ListUsers</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional users.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceInput {
/// <p>Requests the tags associated with a particular Amazon Resource Name (ARN). An ARN is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
/// <p>Specifies the number of tags to return as a response to the <code>ListTagsForResource</code> request.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you request additional results from the <code>ListTagsForResource</code> operation, a <code>NextToken</code> parameter is returned in the input. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional tags.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsForResourceInput {
/// <p>Requests the tags associated with a particular Amazon Resource Name (ARN). An ARN is an identifier for a specific Amazon Web Services resource, such as a server, user, or role.</p>
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
/// <p>Specifies the number of tags to return as a response to the <code>ListTagsForResource</code> request.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you request additional results from the <code>ListTagsForResource</code> operation, a <code>NextToken</code> parameter is returned in the input. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional tags.</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 ListServersInput {
/// <p>Specifies the number of servers to return as a response to the <code>ListServers</code> query.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When additional results are obtained from the <code>ListServers</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional servers.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListServersInput {
/// <p>Specifies the number of servers to return as a response to the <code>ListServers</code> query.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When additional results are obtained from the <code>ListServers</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional servers.</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 ListSecurityPoliciesInput {
/// <p>Specifies the number of security policies to return as a response to the <code>ListSecurityPolicies</code> query.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When additional results are obtained from the <code>ListSecurityPolicies</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional security policies.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListSecurityPoliciesInput {
/// <p>Specifies the number of security policies to return as a response to the <code>ListSecurityPolicies</code> query.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When additional results are obtained from the <code>ListSecurityPolicies</code> command, a <code>NextToken</code> parameter is returned in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional security policies.</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 ListProfilesInput {
/// <p>The maximum number of profiles to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListProfiles</code> to continue listing results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>Indicates whether to list only <code>LOCAL</code> type profiles or only <code>PARTNER</code> type profiles. If not supplied in the request, the command lists all types of profiles.</p>
#[doc(hidden)]
pub profile_type: std::option::Option<crate::model::ProfileType>,
}
impl ListProfilesInput {
/// <p>The maximum number of profiles to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListProfiles</code> to continue listing results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>Indicates whether to list only <code>LOCAL</code> type profiles or only <code>PARTNER</code> type profiles. If not supplied in the request, the command lists all types of profiles.</p>
pub fn profile_type(&self) -> std::option::Option<&crate::model::ProfileType> {
self.profile_type.as_ref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListHostKeysInput {
/// <p>The maximum number of host keys to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListHostKeys</code> to continue listing results.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The identifier of the server that contains the host keys that you want to view.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl ListHostKeysInput {
/// <p>The maximum number of host keys to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When there are additional results that were not returned, a <code>NextToken</code> parameter is returned. You can use that value for a subsequent call to <code>ListHostKeys</code> to continue listing results.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The identifier of the server that contains the host keys that you want to view.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListExecutionsInput {
/// <p>Specifies the maximum number of executions to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p> <code>ListExecutions</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional executions.</p>
/// <p> This is useful for pagination, for instance. If you have 100 executions for a workflow, you might only want to list first 10. If so, call the API by specifying the <code>max-results</code>: </p>
/// <p> <code>aws transfer list-executions --max-results 10</code> </p>
/// <p> This returns details for the first 10 executions, as well as the pointer (<code>NextToken</code>) to the eleventh execution. You can now call the API again, supplying the <code>NextToken</code> value you received: </p>
/// <p> <code>aws transfer list-executions --max-results 10 --next-token $somePointerReturnedFromPreviousListResult</code> </p>
/// <p> This call returns the next 10 executions, the 11th through the 20th. You can then repeat the call until the details for all 100 executions have been returned. </p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>A unique identifier for the workflow.</p>
#[doc(hidden)]
pub workflow_id: std::option::Option<std::string::String>,
}
impl ListExecutionsInput {
/// <p>Specifies the maximum number of executions to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p> <code>ListExecutions</code> returns the <code>NextToken</code> parameter in the output. You can then pass the <code>NextToken</code> parameter in a subsequent command to continue listing additional executions.</p>
/// <p> This is useful for pagination, for instance. If you have 100 executions for a workflow, you might only want to list first 10. If so, call the API by specifying the <code>max-results</code>: </p>
/// <p> <code>aws transfer list-executions --max-results 10</code> </p>
/// <p> This returns details for the first 10 executions, as well as the pointer (<code>NextToken</code>) to the eleventh execution. You can now call the API again, supplying the <code>NextToken</code> value you received: </p>
/// <p> <code>aws transfer list-executions --max-results 10 --next-token $somePointerReturnedFromPreviousListResult</code> </p>
/// <p> This call returns the next 10 executions, the 11th through the 20th. You can then repeat the call until the details for all 100 executions have been returned. </p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(&self) -> std::option::Option<&str> {
self.workflow_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListConnectorsInput {
/// <p>The maximum number of connectors to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you can get additional results from the <code>ListConnectors</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional connectors.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListConnectorsInput {
/// <p>The maximum number of connectors to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you can get additional results from the <code>ListConnectors</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional connectors.</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 ListCertificatesInput {
/// <p>The maximum number of certificates to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you can get additional results from the <code>ListCertificates</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional certificates.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListCertificatesInput {
/// <p>The maximum number of certificates to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you can get additional results from the <code>ListCertificates</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional certificates.</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 ListAgreementsInput {
/// <p>The maximum number of agreements to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you can get additional results from the <code>ListAgreements</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional agreements.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>The identifier of the server for which you want a list of agreements.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl ListAgreementsInput {
/// <p>The maximum number of agreements to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you can get additional results from the <code>ListAgreements</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional agreements.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>The identifier of the server for which you want a list of agreements.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListAccessesInput {
/// <p>Specifies the maximum number of access SIDs to return.</p>
#[doc(hidden)]
pub max_results: std::option::Option<i32>,
/// <p>When you can get additional results from the <code>ListAccesses</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional accesses.</p>
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl ListAccessesInput {
/// <p>Specifies the maximum number of access SIDs to return.</p>
pub fn max_results(&self) -> std::option::Option<i32> {
self.max_results
}
/// <p>When you can get additional results from the <code>ListAccesses</code> call, a <code>NextToken</code> parameter is returned in the output. You can then pass in a subsequent command to the <code>NextToken</code> parameter to continue listing additional accesses.</p>
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
/// <p>A system-assigned unique identifier for a server that has users assigned to it.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ImportSshPublicKeyInput {
/// <p>A system-assigned unique identifier for a server.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
#[doc(hidden)]
pub ssh_public_key_body: std::option::Option<std::string::String>,
/// <p>The name of the user account that is assigned to one or more servers.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl ImportSshPublicKeyInput {
/// <p>A system-assigned unique identifier for a server.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn ssh_public_key_body(&self) -> std::option::Option<&str> {
self.ssh_public_key_body.as_deref()
}
/// <p>The name of the user account that is assigned to one or more servers.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ImportHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are importing.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
#[doc(hidden)]
pub host_key_body: std::option::Option<std::string::String>,
/// <p>The text description that identifies this host key.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Key-value pairs that can be used to group and search for host keys.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl ImportHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are importing.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The public key portion of an SSH key pair.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn host_key_body(&self) -> std::option::Option<&str> {
self.host_key_body.as_deref()
}
/// <p>The text description that identifies this host key.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for host keys.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for ImportHostKeyInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ImportHostKeyInput");
formatter.field("server_id", &self.server_id);
formatter.field("host_key_body", &"*** Sensitive Data Redacted ***");
formatter.field("description", &self.description);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ImportCertificateInput {
/// <p>Specifies whether this certificate is used for signing or encryption.</p>
#[doc(hidden)]
pub usage: std::option::Option<crate::model::CertificateUsageType>,
/// <p>The file that contains the certificate to import.</p>
#[doc(hidden)]
pub certificate: std::option::Option<std::string::String>,
/// <p>An optional list of certificates that make up the chain for the certificate that's being imported.</p>
#[doc(hidden)]
pub certificate_chain: std::option::Option<std::string::String>,
/// <p>The file that contains the private key for the certificate that's being imported.</p>
#[doc(hidden)]
pub private_key: std::option::Option<std::string::String>,
/// <p>An optional date that specifies when the certificate becomes active.</p>
#[doc(hidden)]
pub active_date: std::option::Option<aws_smithy_types::DateTime>,
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
#[doc(hidden)]
pub inactive_date: std::option::Option<aws_smithy_types::DateTime>,
/// <p>A short description that helps identify the certificate. </p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Key-value pairs that can be used to group and search for certificates.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl ImportCertificateInput {
/// <p>Specifies whether this certificate is used for signing or encryption.</p>
pub fn usage(&self) -> std::option::Option<&crate::model::CertificateUsageType> {
self.usage.as_ref()
}
/// <p>The file that contains the certificate to import.</p>
pub fn certificate(&self) -> std::option::Option<&str> {
self.certificate.as_deref()
}
/// <p>An optional list of certificates that make up the chain for the certificate that's being imported.</p>
pub fn certificate_chain(&self) -> std::option::Option<&str> {
self.certificate_chain.as_deref()
}
/// <p>The file that contains the private key for the certificate that's being imported.</p>
pub fn private_key(&self) -> std::option::Option<&str> {
self.private_key.as_deref()
}
/// <p>An optional date that specifies when the certificate becomes active.</p>
pub fn active_date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.active_date.as_ref()
}
/// <p>An optional date that specifies when the certificate becomes inactive.</p>
pub fn inactive_date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.inactive_date.as_ref()
}
/// <p>A short description that helps identify the certificate. </p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for certificates.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
impl std::fmt::Debug for ImportCertificateInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("ImportCertificateInput");
formatter.field("usage", &self.usage);
formatter.field("certificate", &"*** Sensitive Data Redacted ***");
formatter.field("certificate_chain", &"*** Sensitive Data Redacted ***");
formatter.field("private_key", &"*** Sensitive Data Redacted ***");
formatter.field("active_date", &self.active_date);
formatter.field("inactive_date", &self.inactive_date);
formatter.field("description", &self.description);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeWorkflowInput {
/// <p>A unique identifier for the workflow.</p>
#[doc(hidden)]
pub workflow_id: std::option::Option<std::string::String>,
}
impl DescribeWorkflowInput {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(&self) -> std::option::Option<&str> {
self.workflow_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeUserInput {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The name of the user assigned to one or more servers. User names are part of the sign-in credentials to use the Transfer Family service and perform file transfer tasks.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl DescribeUserInput {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The name of the user assigned to one or more servers. User names are part of the sign-in credentials to use the Transfer Family service and perform file transfer tasks.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeServerInput {
/// <p>A system-assigned unique identifier for a server.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl DescribeServerInput {
/// <p>A system-assigned unique identifier for a server.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeSecurityPolicyInput {
/// <p>Specifies the name of the security policy that is attached to the server.</p>
#[doc(hidden)]
pub security_policy_name: std::option::Option<std::string::String>,
}
impl DescribeSecurityPolicyInput {
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(&self) -> std::option::Option<&str> {
self.security_policy_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeProfileInput {
/// <p>The identifier of the profile that you want described.</p>
#[doc(hidden)]
pub profile_id: std::option::Option<std::string::String>,
}
impl DescribeProfileInput {
/// <p>The identifier of the profile that you want described.</p>
pub fn profile_id(&self) -> std::option::Option<&str> {
self.profile_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeHostKeyInput {
/// <p>The identifier of the server that contains the host key that you want described.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The identifier of the host key that you want described.</p>
#[doc(hidden)]
pub host_key_id: std::option::Option<std::string::String>,
}
impl DescribeHostKeyInput {
/// <p>The identifier of the server that contains the host key that you want described.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The identifier of the host key that you want described.</p>
pub fn host_key_id(&self) -> std::option::Option<&str> {
self.host_key_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeExecutionInput {
/// <p>A unique identifier for the execution of a workflow.</p>
#[doc(hidden)]
pub execution_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the workflow.</p>
#[doc(hidden)]
pub workflow_id: std::option::Option<std::string::String>,
}
impl DescribeExecutionInput {
/// <p>A unique identifier for the execution of a workflow.</p>
pub fn execution_id(&self) -> std::option::Option<&str> {
self.execution_id.as_deref()
}
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(&self) -> std::option::Option<&str> {
self.workflow_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConnectorInput {
/// <p>The unique identifier for the connector.</p>
#[doc(hidden)]
pub connector_id: std::option::Option<std::string::String>,
}
impl DescribeConnectorInput {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(&self) -> std::option::Option<&str> {
self.connector_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeCertificateInput {
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
#[doc(hidden)]
pub certificate_id: std::option::Option<std::string::String>,
}
impl DescribeCertificateInput {
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_id(&self) -> std::option::Option<&str> {
self.certificate_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
#[doc(hidden)]
pub agreement_id: std::option::Option<std::string::String>,
/// <p>The server identifier that's associated with the agreement.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl DescribeAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(&self) -> std::option::Option<&str> {
self.agreement_id.as_deref()
}
/// <p>The server identifier that's associated with the agreement.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeAccessInput {
/// <p>A system-assigned unique identifier for a server that has this access assigned.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
#[doc(hidden)]
pub external_id: std::option::Option<std::string::String>,
}
impl DescribeAccessInput {
/// <p>A system-assigned unique identifier for a server that has this access assigned.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(&self) -> std::option::Option<&str> {
self.external_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteWorkflowInput {
/// <p>A unique identifier for the workflow.</p>
#[doc(hidden)]
pub workflow_id: std::option::Option<std::string::String>,
}
impl DeleteWorkflowInput {
/// <p>A unique identifier for the workflow.</p>
pub fn workflow_id(&self) -> std::option::Option<&str> {
self.workflow_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteUserInput {
/// <p>A system-assigned unique identifier for a server instance that has the user assigned to it.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique string that identifies a user that is being deleted from a server.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl DeleteUserInput {
/// <p>A system-assigned unique identifier for a server instance that has the user assigned to it.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique string that identifies a user that is being deleted from a server.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteSshPublicKeyInput {
/// <p>A system-assigned unique identifier for a file transfer protocol-enabled server instance that has the user assigned to it.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier used to reference your user's specific SSH key.</p>
#[doc(hidden)]
pub ssh_public_key_id: std::option::Option<std::string::String>,
/// <p>A unique string that identifies a user whose public key is being deleted.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl DeleteSshPublicKeyInput {
/// <p>A system-assigned unique identifier for a file transfer protocol-enabled server instance that has the user assigned to it.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier used to reference your user's specific SSH key.</p>
pub fn ssh_public_key_id(&self) -> std::option::Option<&str> {
self.ssh_public_key_id.as_deref()
}
/// <p>A unique string that identifies a user whose public key is being deleted.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteServerInput {
/// <p>A unique system-assigned identifier for a server instance.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl DeleteServerInput {
/// <p>A unique system-assigned identifier for a server instance.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteProfileInput {
/// <p>The identifier of the profile that you are deleting.</p>
#[doc(hidden)]
pub profile_id: std::option::Option<std::string::String>,
}
impl DeleteProfileInput {
/// <p>The identifier of the profile that you are deleting.</p>
pub fn profile_id(&self) -> std::option::Option<&str> {
self.profile_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are deleting.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The identifier of the host key that you are deleting.</p>
#[doc(hidden)]
pub host_key_id: std::option::Option<std::string::String>,
}
impl DeleteHostKeyInput {
/// <p>The identifier of the server that contains the host key that you are deleting.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The identifier of the host key that you are deleting.</p>
pub fn host_key_id(&self) -> std::option::Option<&str> {
self.host_key_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConnectorInput {
/// <p>The unique identifier for the connector.</p>
#[doc(hidden)]
pub connector_id: std::option::Option<std::string::String>,
}
impl DeleteConnectorInput {
/// <p>The unique identifier for the connector.</p>
pub fn connector_id(&self) -> std::option::Option<&str> {
self.connector_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteCertificateInput {
/// <p>The identifier of the certificate object that you are deleting.</p>
#[doc(hidden)]
pub certificate_id: std::option::Option<std::string::String>,
}
impl DeleteCertificateInput {
/// <p>The identifier of the certificate object that you are deleting.</p>
pub fn certificate_id(&self) -> std::option::Option<&str> {
self.certificate_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
#[doc(hidden)]
pub agreement_id: std::option::Option<std::string::String>,
/// <p>The server identifier associated with the agreement that you are deleting.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
}
impl DeleteAgreementInput {
/// <p>A unique identifier for the agreement. This identifier is returned when you create an agreement.</p>
pub fn agreement_id(&self) -> std::option::Option<&str> {
self.agreement_id.as_deref()
}
/// <p>The server identifier associated with the agreement that you are deleting.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteAccessInput {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
#[doc(hidden)]
pub external_id: std::option::Option<std::string::String>,
}
impl DeleteAccessInput {
/// <p>A system-assigned unique identifier for a server that has this user assigned.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(&self) -> std::option::Option<&str> {
self.external_id.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateWorkflowInput {
/// <p>A textual description for the workflow.</p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>Specifies the details for the steps that are in the specified workflow.</p>
/// <p> The <code>TYPE</code> specifies which of the following actions is being taken for this step. </p>
/// <ul>
/// <li> <p> <i>COPY</i>: Copy the file to another location.</p> </li>
/// <li> <p> <i>CUSTOM</i>: Perform a custom step with an Lambda function target.</p> </li>
/// <li> <p> <i>DELETE</i>: Delete the file.</p> </li>
/// <li> <p> <i>TAG</i>: Add a tag to the file.</p> </li>
/// </ul> <note>
/// <p> Currently, copying and tagging are supported only on S3. </p>
/// </note>
/// <p> For file location, you specify either the S3 bucket and key, or the EFS file system ID and path. </p>
#[doc(hidden)]
pub steps: std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
/// <p>Specifies the steps (actions) to take if errors are encountered during execution of the workflow.</p> <note>
/// <p>For custom steps, the lambda function needs to send <code>FAILURE</code> to the call back API to kick off the exception steps. Additionally, if the lambda does not send <code>SUCCESS</code> before it times out, the exception steps are executed.</p>
/// </note>
#[doc(hidden)]
pub on_exception_steps: std::option::Option<std::vec::Vec<crate::model::WorkflowStep>>,
/// <p>Key-value pairs that can be used to group and search for workflows. Tags are metadata attached to workflows for any purpose.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateWorkflowInput {
/// <p>A textual description for the workflow.</p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>Specifies the details for the steps that are in the specified workflow.</p>
/// <p> The <code>TYPE</code> specifies which of the following actions is being taken for this step. </p>
/// <ul>
/// <li> <p> <i>COPY</i>: Copy the file to another location.</p> </li>
/// <li> <p> <i>CUSTOM</i>: Perform a custom step with an Lambda function target.</p> </li>
/// <li> <p> <i>DELETE</i>: Delete the file.</p> </li>
/// <li> <p> <i>TAG</i>: Add a tag to the file.</p> </li>
/// </ul> <note>
/// <p> Currently, copying and tagging are supported only on S3. </p>
/// </note>
/// <p> For file location, you specify either the S3 bucket and key, or the EFS file system ID and path. </p>
pub fn steps(&self) -> std::option::Option<&[crate::model::WorkflowStep]> {
self.steps.as_deref()
}
/// <p>Specifies the steps (actions) to take if errors are encountered during execution of the workflow.</p> <note>
/// <p>For custom steps, the lambda function needs to send <code>FAILURE</code> to the call back API to kick off the exception steps. Additionally, if the lambda does not send <code>SUCCESS</code> before it times out, the exception steps are executed.</p>
/// </note>
pub fn on_exception_steps(&self) -> std::option::Option<&[crate::model::WorkflowStep]> {
self.on_exception_steps.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for workflows. Tags are metadata attached to workflows for any purpose.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateUserInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
#[doc(hidden)]
pub home_directory: std::option::Option<std::string::String>,
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
#[doc(hidden)]
pub home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock your user down to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
#[doc(hidden)]
pub home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
#[doc(hidden)]
pub policy: std::option::Option<std::string::String>,
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in Amazon EFS determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
#[doc(hidden)]
pub posix_profile: std::option::Option<crate::model::PosixProfile>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>The public portion of the Secure Shell (SSH) key used to authenticate the user to the server.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
#[doc(hidden)]
pub ssh_public_key_body: std::option::Option<std::string::String>,
/// <p>Key-value pairs that can be used to group and search for users. Tags are metadata attached to users for any purpose.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
/// <p>A unique string that identifies a user and is associated with a <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
#[doc(hidden)]
pub user_name: std::option::Option<std::string::String>,
}
impl CreateUserInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(&self) -> std::option::Option<&str> {
self.home_directory.as_deref()
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(&self) -> std::option::Option<&crate::model::HomeDirectoryType> {
self.home_directory_type.as_ref()
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock your user down to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the HomeDirectory parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
&self,
) -> std::option::Option<&[crate::model::HomeDirectoryMapEntry]> {
self.home_directory_mappings.as_deref()
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Amazon Web Services Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(&self) -> std::option::Option<&str> {
self.policy.as_deref()
}
/// <p>Specifies the full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in Amazon EFS determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(&self) -> std::option::Option<&crate::model::PosixProfile> {
self.posix_profile.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>The public portion of the Secure Shell (SSH) key used to authenticate the user to the server.</p>
/// <p>Transfer Family accepts RSA, ECDSA, and ED25519 keys.</p>
pub fn ssh_public_key_body(&self) -> std::option::Option<&str> {
self.ssh_public_key_body.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for users. Tags are metadata attached to users for any purpose.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
/// <p>A unique string that identifies a user and is associated with a <code>ServerId</code>. This user name must be a minimum of 3 and a maximum of 100 characters long. The following are valid characters: a-z, A-Z, 0-9, underscore '_', hyphen '-', period '.', and at sign '@'. The user name can't start with a hyphen, period, or at sign.</p>
pub fn user_name(&self) -> std::option::Option<&str> {
self.user_name.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateServerInput {
/// <p>The Amazon Resource Name (ARN) of the Certificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
#[doc(hidden)]
pub certificate: std::option::Option<std::string::String>,
/// <p>The domain of the storage system that is used for file transfers. There are two domains available: Amazon Simple Storage Service (Amazon S3) and Amazon Elastic File System (Amazon EFS). The default value is S3.</p> <note>
/// <p>After the server is created, the domain cannot be changed.</p>
/// </note>
#[doc(hidden)]
pub domain: std::option::Option<crate::model::Domain>,
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
#[doc(hidden)]
pub endpoint_details: std::option::Option<crate::model::EndpointDetails>,
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
#[doc(hidden)]
pub endpoint_type: std::option::Option<crate::model::EndpointType>,
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
#[doc(hidden)]
pub host_key: std::option::Option<std::string::String>,
/// <p>Required when <code>IdentityProviderType</code> is set to <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>. Accepts an array containing all of the information required to use a directory in <code>AWS_DIRECTORY_SERVICE</code> or invoke a customer-supplied authentication API, including the API Gateway URL. Not required when <code>IdentityProviderType</code> is set to <code>SERVICE_MANAGED</code>.</p>
#[doc(hidden)]
pub identity_provider_details: std::option::Option<crate::model::IdentityProviderDetails>,
/// <p>The mode of authentication for a server. The default value is <code>SERVICE_MANAGED</code>, which allows you to store and access user credentials within the Transfer Family service.</p>
/// <p>Use <code>AWS_DIRECTORY_SERVICE</code> to provide access to Active Directory groups in Directory Service for Microsoft Active Directory or Microsoft Active Directory in your on-premises environment or in Amazon Web Services using AD Connector. This option also requires you to provide a Directory ID by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>API_GATEWAY</code> value to integrate with an identity provider of your choosing. The <code>API_GATEWAY</code> setting requires you to provide an Amazon API Gateway endpoint URL to call for authentication by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>AWS_LAMBDA</code> value to directly use an Lambda function as your identity provider. If you choose this value, you must specify the ARN for the Lambda function in the <code>Function</code> parameter or the <code>IdentityProviderDetails</code> data type.</p>
#[doc(hidden)]
pub identity_provider_type: std::option::Option<crate::model::IdentityProviderType>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
#[doc(hidden)]
pub logging_role: std::option::Option<std::string::String>,
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
#[doc(hidden)]
pub post_authentication_login_banner: std::option::Option<std::string::String>,
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
#[doc(hidden)]
pub pre_authentication_login_banner: std::option::Option<std::string::String>,
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
#[doc(hidden)]
pub protocols: std::option::Option<std::vec::Vec<crate::model::Protocol>>,
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
#[doc(hidden)]
pub protocol_details: std::option::Option<crate::model::ProtocolDetails>,
/// <p>Specifies the name of the security policy that is attached to the server.</p>
#[doc(hidden)]
pub security_policy_name: std::option::Option<std::string::String>,
/// <p>Key-value pairs that can be used to group and search for servers.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
#[doc(hidden)]
pub workflow_details: std::option::Option<crate::model::WorkflowDetails>,
}
impl CreateServerInput {
/// <p>The Amazon Resource Name (ARN) of the Certificate Manager (ACM) certificate. Required when <code>Protocols</code> is set to <code>FTPS</code>.</p>
/// <p>To request a new public certificate, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a public certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To import an existing certificate into ACM, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html">Importing certificates into ACM</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>To request a private certificate to use FTPS through private IP addresses, see <a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-private.html">Request a private certificate</a> in the <i>Certificate Manager User Guide</i>.</p>
/// <p>Certificates with the following cryptographic algorithms and key sizes are supported:</p>
/// <ul>
/// <li> <p>2048-bit RSA (RSA_2048)</p> </li>
/// <li> <p>4096-bit RSA (RSA_4096)</p> </li>
/// <li> <p>Elliptic Prime Curve 256 bit (EC_prime256v1)</p> </li>
/// <li> <p>Elliptic Prime Curve 384 bit (EC_secp384r1)</p> </li>
/// <li> <p>Elliptic Prime Curve 521 bit (EC_secp521r1)</p> </li>
/// </ul> <note>
/// <p>The certificate must be a valid SSL/TLS X.509 version 3 certificate with FQDN or IP address specified and information about the issuer.</p>
/// </note>
pub fn certificate(&self) -> std::option::Option<&str> {
self.certificate.as_deref()
}
/// <p>The domain of the storage system that is used for file transfers. There are two domains available: Amazon Simple Storage Service (Amazon S3) and Amazon Elastic File System (Amazon EFS). The default value is S3.</p> <note>
/// <p>After the server is created, the domain cannot be changed.</p>
/// </note>
pub fn domain(&self) -> std::option::Option<&crate::model::Domain> {
self.domain.as_ref()
}
/// <p>The virtual private cloud (VPC) endpoint settings that are configured for your server. When you host your endpoint within your VPC, you can make your endpoint accessible only to resources within your VPC, or you can attach Elastic IP addresses and make your endpoint accessible to clients over the internet. Your VPC's default security groups are automatically assigned to your endpoint.</p>
pub fn endpoint_details(&self) -> std::option::Option<&crate::model::EndpointDetails> {
self.endpoint_details.as_ref()
}
/// <p>The type of endpoint that you want your server to use. You can choose to make your server's endpoint publicly accessible (PUBLIC) or host it inside your VPC. With an endpoint that is hosted in a VPC, you can restrict access to your server and resources only within your VPC or choose to make it internet facing by attaching Elastic IP addresses directly to it.</p> <note>
/// <p> After May 19, 2021, you won't be able to create a server using <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account if your account hasn't already done so before May 19, 2021. If you have already created servers with <code>EndpointType=VPC_ENDPOINT</code> in your Amazon Web Services account on or before May 19, 2021, you will not be affected. After this date, use <code>EndpointType</code>=<code>VPC</code>.</p>
/// <p>For more information, see https://docs.aws.amazon.com/transfer/latest/userguide/create-server-in-vpc.html#deprecate-vpc-endpoint.</p>
/// <p>It is recommended that you use <code>VPC</code> as the <code>EndpointType</code>. With this endpoint type, you have the option to directly associate up to three Elastic IPv4 addresses (BYO IP included) with your server's endpoint and use VPC security groups to restrict traffic by the client's public IP address. This is not possible with <code>EndpointType</code> set to <code>VPC_ENDPOINT</code>.</p>
/// </note>
pub fn endpoint_type(&self) -> std::option::Option<&crate::model::EndpointType> {
self.endpoint_type.as_ref()
}
/// <p>The RSA, ECDSA, or ED25519 private key to use for your SFTP-enabled server. You can add multiple host keys, in case you want to rotate keys, or have a set of active keys that use different algorithms.</p>
/// <p>Use the following command to generate an RSA 2048 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t rsa -b 2048 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Use a minimum value of 2048 for the <code>-b</code> option. You can create a stronger key by using 3072 or 4096.</p>
/// <p>Use the following command to generate an ECDSA 256 bit key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ecdsa -b 256 -N "" -m PEM -f my-new-server-key</code>.</p>
/// <p>Valid values for the <code>-b</code> option for ECDSA are 256, 384, and 521.</p>
/// <p>Use the following command to generate an ED25519 key with no passphrase:</p>
/// <p> <code>ssh-keygen -t ed25519 -N "" -f my-new-server-key</code>.</p>
/// <p>For all of these commands, you can replace <i>my-new-server-key</i> with a string of your choice.</p> <important>
/// <p>If you aren't planning to migrate existing users from an existing SFTP-enabled server to a new server, don't update the host key. Accidentally changing a server's host key can be disruptive.</p>
/// </important>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/edit-server-config.html#configuring-servers-change-host-key">Update host keys for your SFTP-enabled server</a> in the <i>Transfer Family User Guide</i>.</p>
pub fn host_key(&self) -> std::option::Option<&str> {
self.host_key.as_deref()
}
/// <p>Required when <code>IdentityProviderType</code> is set to <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>. Accepts an array containing all of the information required to use a directory in <code>AWS_DIRECTORY_SERVICE</code> or invoke a customer-supplied authentication API, including the API Gateway URL. Not required when <code>IdentityProviderType</code> is set to <code>SERVICE_MANAGED</code>.</p>
pub fn identity_provider_details(
&self,
) -> std::option::Option<&crate::model::IdentityProviderDetails> {
self.identity_provider_details.as_ref()
}
/// <p>The mode of authentication for a server. The default value is <code>SERVICE_MANAGED</code>, which allows you to store and access user credentials within the Transfer Family service.</p>
/// <p>Use <code>AWS_DIRECTORY_SERVICE</code> to provide access to Active Directory groups in Directory Service for Microsoft Active Directory or Microsoft Active Directory in your on-premises environment or in Amazon Web Services using AD Connector. This option also requires you to provide a Directory ID by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>API_GATEWAY</code> value to integrate with an identity provider of your choosing. The <code>API_GATEWAY</code> setting requires you to provide an Amazon API Gateway endpoint URL to call for authentication by using the <code>IdentityProviderDetails</code> parameter.</p>
/// <p>Use the <code>AWS_LAMBDA</code> value to directly use an Lambda function as your identity provider. If you choose this value, you must specify the ARN for the Lambda function in the <code>Function</code> parameter or the <code>IdentityProviderDetails</code> data type.</p>
pub fn identity_provider_type(
&self,
) -> std::option::Option<&crate::model::IdentityProviderType> {
self.identity_provider_type.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a server to turn on Amazon CloudWatch logging for Amazon S3 or Amazon EFSevents. When set, you can view user activity in your CloudWatch logs.</p>
pub fn logging_role(&self) -> std::option::Option<&str> {
self.logging_role.as_deref()
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed after the user authenticates.</p> <note>
/// <p>The SFTP protocol does not support post-authentication display banners.</p>
/// </note>
pub fn post_authentication_login_banner(&self) -> std::option::Option<&str> {
self.post_authentication_login_banner.as_deref()
}
/// <p>Specifies a string to display when users connect to a server. This string is displayed before the user authenticates. For example, the following banner displays details about using the system:</p>
/// <p> <code>This system is for the use of authorized users only. Individuals using this computer system without authority, or in excess of their authority, are subject to having all of their activities on this system monitored and recorded by system personnel.</code> </p>
pub fn pre_authentication_login_banner(&self) -> std::option::Option<&str> {
self.pre_authentication_login_banner.as_deref()
}
/// <p>Specifies the file transfer protocol or protocols over which your file transfer protocol client can connect to your server's endpoint. The available protocols are:</p>
/// <ul>
/// <li> <p> <code>SFTP</code> (Secure Shell (SSH) File Transfer Protocol): File transfer over SSH</p> </li>
/// <li> <p> <code>FTPS</code> (File Transfer Protocol Secure): File transfer with TLS encryption</p> </li>
/// <li> <p> <code>FTP</code> (File Transfer Protocol): Unencrypted file transfer</p> </li>
/// <li> <p> <code>AS2</code> (Applicability Statement 2): used for transporting structured business-to-business data</p> </li>
/// </ul> <note>
/// <ul>
/// <li> <p>If you select <code>FTPS</code>, you must choose a certificate stored in Certificate Manager (ACM) which is used to identify your server when clients connect to it over FTPS.</p> </li>
/// <li> <p>If <code>Protocol</code> includes either <code>FTP</code> or <code>FTPS</code>, then the <code>EndpointType</code> must be <code>VPC</code> and the <code>IdentityProviderType</code> must be <code>AWS_DIRECTORY_SERVICE</code> or <code>API_GATEWAY</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>FTP</code>, then <code>AddressAllocationIds</code> cannot be associated.</p> </li>
/// <li> <p>If <code>Protocol</code> is set only to <code>SFTP</code>, the <code>EndpointType</code> can be set to <code>PUBLIC</code> and the <code>IdentityProviderType</code> can be set to <code>SERVICE_MANAGED</code>.</p> </li>
/// <li> <p>If <code>Protocol</code> includes <code>AS2</code>, then the <code>EndpointType</code> must be <code>VPC</code>, and domain must be Amazon S3.</p> </li>
/// </ul>
/// </note>
pub fn protocols(&self) -> std::option::Option<&[crate::model::Protocol]> {
self.protocols.as_deref()
}
/// <p>The protocol settings that are configured for your server.</p>
/// <ul>
/// <li> <p> To indicate passive mode (for FTP and FTPS protocols), use the <code>PassiveIp</code> parameter. Enter a single dotted-quad IPv4 address, such as the external IP address of a firewall, router, or load balancer. </p> </li>
/// <li> <p>To ignore the error that is generated when the client attempts to use the <code>SETSTAT</code> command on a file that you are uploading to an Amazon S3 bucket, use the <code>SetStatOption</code> parameter. To have the Transfer Family server ignore the <code>SETSTAT</code> command and upload files without needing to make any changes to your SFTP client, set the value to <code>ENABLE_NO_OP</code>. If you set the <code>SetStatOption</code> parameter to <code>ENABLE_NO_OP</code>, Transfer Family generates a log entry to Amazon CloudWatch Logs, so that you can determine when the client is making a <code>SETSTAT</code> call.</p> </li>
/// <li> <p>To determine whether your Transfer Family server resumes recent, negotiated sessions through a unique session ID, use the <code>TlsSessionResumptionMode</code> parameter.</p> </li>
/// <li> <p> <code>As2Transports</code> indicates the transport method for the AS2 messages. Currently, only HTTP is supported.</p> </li>
/// </ul>
pub fn protocol_details(&self) -> std::option::Option<&crate::model::ProtocolDetails> {
self.protocol_details.as_ref()
}
/// <p>Specifies the name of the security policy that is attached to the server.</p>
pub fn security_policy_name(&self) -> std::option::Option<&str> {
self.security_policy_name.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for servers.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
/// <p>Specifies the workflow ID for the workflow to assign and the execution role that's used for executing the workflow.</p>
/// <p>In additon to a workflow to execute when a file is uploaded completely, <code>WorkflowDeatails</code> can also contain a workflow ID (and execution role) for a workflow to execute on partial upload. A partial upload occurs when a file is open when the session disconnects.</p>
pub fn workflow_details(&self) -> std::option::Option<&crate::model::WorkflowDetails> {
self.workflow_details.as_ref()
}
}
impl std::fmt::Debug for CreateServerInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("CreateServerInput");
formatter.field("certificate", &self.certificate);
formatter.field("domain", &self.domain);
formatter.field("endpoint_details", &self.endpoint_details);
formatter.field("endpoint_type", &self.endpoint_type);
formatter.field("host_key", &"*** Sensitive Data Redacted ***");
formatter.field("identity_provider_details", &self.identity_provider_details);
formatter.field("identity_provider_type", &self.identity_provider_type);
formatter.field("logging_role", &self.logging_role);
formatter.field(
"post_authentication_login_banner",
&self.post_authentication_login_banner,
);
formatter.field(
"pre_authentication_login_banner",
&self.pre_authentication_login_banner,
);
formatter.field("protocols", &self.protocols);
formatter.field("protocol_details", &self.protocol_details);
formatter.field("security_policy_name", &self.security_policy_name);
formatter.field("tags", &self.tags);
formatter.field("workflow_details", &self.workflow_details);
formatter.finish()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateProfileInput {
/// <p>The <code>As2Id</code> is the <i>AS2-name</i>, as defined in the <a href="https://datatracker.ietf.org/doc/html/rfc4130">RFC 4130</a>. For inbound transfers, this is the <code>AS2-From</code> header for the AS2 messages sent from the partner. For outbound connectors, this is the <code>AS2-To</code> header for the AS2 messages sent to the partner using the <code>StartFileTransfer</code> API operation. This ID cannot include spaces.</p>
#[doc(hidden)]
pub as2_id: std::option::Option<std::string::String>,
/// <p>Determines the type of profile to create:</p>
/// <ul>
/// <li> <p>Specify <code>LOCAL</code> to create a local profile. A local profile represents the AS2-enabled Transfer Family server organization or party.</p> </li>
/// <li> <p>Specify <code>PARTNER</code> to create a partner profile. A partner profile represents a remote organization, external to Transfer Family.</p> </li>
/// </ul>
#[doc(hidden)]
pub profile_type: std::option::Option<crate::model::ProfileType>,
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
#[doc(hidden)]
pub certificate_ids: std::option::Option<std::vec::Vec<std::string::String>>,
/// <p>Key-value pairs that can be used to group and search for AS2 profiles.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateProfileInput {
/// <p>The <code>As2Id</code> is the <i>AS2-name</i>, as defined in the <a href="https://datatracker.ietf.org/doc/html/rfc4130">RFC 4130</a>. For inbound transfers, this is the <code>AS2-From</code> header for the AS2 messages sent from the partner. For outbound connectors, this is the <code>AS2-To</code> header for the AS2 messages sent to the partner using the <code>StartFileTransfer</code> API operation. This ID cannot include spaces.</p>
pub fn as2_id(&self) -> std::option::Option<&str> {
self.as2_id.as_deref()
}
/// <p>Determines the type of profile to create:</p>
/// <ul>
/// <li> <p>Specify <code>LOCAL</code> to create a local profile. A local profile represents the AS2-enabled Transfer Family server organization or party.</p> </li>
/// <li> <p>Specify <code>PARTNER</code> to create a partner profile. A partner profile represents a remote organization, external to Transfer Family.</p> </li>
/// </ul>
pub fn profile_type(&self) -> std::option::Option<&crate::model::ProfileType> {
self.profile_type.as_ref()
}
/// <p>An array of identifiers for the imported certificates. You use this identifier for working with profiles and partner profiles.</p>
pub fn certificate_ids(&self) -> std::option::Option<&[std::string::String]> {
self.certificate_ids.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for AS2 profiles.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateConnectorInput {
/// <p>The URL of the partner's AS2 endpoint.</p>
#[doc(hidden)]
pub url: std::option::Option<std::string::String>,
/// <p>A structure that contains the parameters for a connector object.</p>
#[doc(hidden)]
pub as2_config: std::option::Option<crate::model::As2ConnectorConfig>,
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
#[doc(hidden)]
pub access_role: std::option::Option<std::string::String>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
#[doc(hidden)]
pub logging_role: std::option::Option<std::string::String>,
/// <p>Key-value pairs that can be used to group and search for connectors. Tags are metadata attached to connectors for any purpose.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateConnectorInput {
/// <p>The URL of the partner's AS2 endpoint.</p>
pub fn url(&self) -> std::option::Option<&str> {
self.url.as_deref()
}
/// <p>A structure that contains the parameters for a connector object.</p>
pub fn as2_config(&self) -> std::option::Option<&crate::model::As2ConnectorConfig> {
self.as2_config.as_ref()
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(&self) -> std::option::Option<&str> {
self.access_role.as_deref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that allows a connector to turn on CloudWatch logging for Amazon S3 events. When set, you can view connector activity in your CloudWatch logs.</p>
pub fn logging_role(&self) -> std::option::Option<&str> {
self.logging_role.as_deref()
}
/// <p>Key-value pairs that can be used to group and search for connectors. Tags are metadata attached to connectors for any purpose.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateAgreementInput {
/// <p>A name or short description to identify the agreement. </p>
#[doc(hidden)]
pub description: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the AS2 local profile.</p>
#[doc(hidden)]
pub local_profile_id: std::option::Option<std::string::String>,
/// <p>A unique identifier for the partner profile used in the agreement.</p>
#[doc(hidden)]
pub partner_profile_id: std::option::Option<std::string::String>,
/// <p>The landing directory (folder) for files transferred by using the AS2 protocol.</p>
/// <p>A <code>BaseDirectory</code> example is <i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i>.</p>
#[doc(hidden)]
pub base_directory: std::option::Option<std::string::String>,
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
#[doc(hidden)]
pub access_role: std::option::Option<std::string::String>,
/// <p>The status of the agreement. The agreement can be either <code>ACTIVE</code> or <code>INACTIVE</code>.</p>
#[doc(hidden)]
pub status: std::option::Option<crate::model::AgreementStatusType>,
/// <p>Key-value pairs that can be used to group and search for agreements.</p>
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl CreateAgreementInput {
/// <p>A name or short description to identify the agreement. </p>
pub fn description(&self) -> std::option::Option<&str> {
self.description.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that the agreement uses.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier for the AS2 local profile.</p>
pub fn local_profile_id(&self) -> std::option::Option<&str> {
self.local_profile_id.as_deref()
}
/// <p>A unique identifier for the partner profile used in the agreement.</p>
pub fn partner_profile_id(&self) -> std::option::Option<&str> {
self.partner_profile_id.as_deref()
}
/// <p>The landing directory (folder) for files transferred by using the AS2 protocol.</p>
/// <p>A <code>BaseDirectory</code> example is <i>DOC-EXAMPLE-BUCKET</i>/<i>home</i>/<i>mydirectory</i>.</p>
pub fn base_directory(&self) -> std::option::Option<&str> {
self.base_directory.as_deref()
}
/// <p>With AS2, you can send files by calling <code>StartFileTransfer</code> and specifying the file paths in the request parameter, <code>SendFilePaths</code>. We use the file’s parent directory (for example, for <code>--send-file-paths /bucket/dir/file.txt</code>, parent directory is <code>/bucket/dir/</code>) to temporarily store a processed AS2 message file, store the MDN when we receive them from the partner, and write a final JSON file containing relevant metadata of the transmission. So, the <code>AccessRole</code> needs to provide read and write access to the parent directory of the file location used in the <code>StartFileTransfer</code> request. Additionally, you need to provide read and write access to the parent directory of the files that you intend to send with <code>StartFileTransfer</code>.</p>
pub fn access_role(&self) -> std::option::Option<&str> {
self.access_role.as_deref()
}
/// <p>The status of the agreement. The agreement can be either <code>ACTIVE</code> or <code>INACTIVE</code>.</p>
pub fn status(&self) -> std::option::Option<&crate::model::AgreementStatusType> {
self.status.as_ref()
}
/// <p>Key-value pairs that can be used to group and search for agreements.</p>
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
}
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateAccessInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
#[doc(hidden)]
pub home_directory: std::option::Option<std::string::String>,
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
#[doc(hidden)]
pub home_directory_type: std::option::Option<crate::model::HomeDirectoryType>,
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
#[doc(hidden)]
pub home_directory_mappings:
std::option::Option<std::vec::Vec<crate::model::HomeDirectoryMapEntry>>,
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Security Token Service API Reference</i>.</p>
/// </note>
#[doc(hidden)]
pub policy: std::option::Option<std::string::String>,
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
#[doc(hidden)]
pub posix_profile: std::option::Option<crate::model::PosixProfile>,
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
#[doc(hidden)]
pub role: std::option::Option<std::string::String>,
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
#[doc(hidden)]
pub server_id: std::option::Option<std::string::String>,
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
#[doc(hidden)]
pub external_id: std::option::Option<std::string::String>,
}
impl CreateAccessInput {
/// <p>The landing directory (folder) for a user when they log in to the server using the client.</p>
/// <p>A <code>HomeDirectory</code> example is <code>/bucket_name/home/mydirectory</code>.</p>
pub fn home_directory(&self) -> std::option::Option<&str> {
self.home_directory.as_deref()
}
/// <p>The type of landing directory (folder) that you want your users' home directory to be when they log in to the server. If you set it to <code>PATH</code>, the user will see the absolute Amazon S3 bucket or EFS paths as is in their file transfer protocol clients. If you set it <code>LOGICAL</code>, you need to provide mappings in the <code>HomeDirectoryMappings</code> for how you want to make Amazon S3 or Amazon EFS paths visible to your users.</p>
pub fn home_directory_type(&self) -> std::option::Option<&crate::model::HomeDirectoryType> {
self.home_directory_type.as_ref()
}
/// <p>Logical directory mappings that specify what Amazon S3 or Amazon EFS paths and keys should be visible to your user and how you want to make them visible. You must specify the <code>Entry</code> and <code>Target</code> pair, where <code>Entry</code> shows how the path is made visible and <code>Target</code> is the actual Amazon S3 or Amazon EFS path. If you only specify a target, it is displayed as is. You also must ensure that your Identity and Access Management (IAM) role provides access to paths in <code>Target</code>. This value can be set only when <code>HomeDirectoryType</code> is set to <i>LOGICAL</i>.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example.</p>
/// <p> <code>[ { "Entry": "/directory1", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
/// <p>In most cases, you can use this value instead of the session policy to lock down your user to the designated home directory ("<code>chroot</code>"). To do this, you can set <code>Entry</code> to <code>/</code> and set <code>Target</code> to the <code>HomeDirectory</code> parameter value.</p>
/// <p>The following is an <code>Entry</code> and <code>Target</code> pair example for <code>chroot</code>.</p>
/// <p> <code>[ { "Entry": "/", "Target": "/bucket_name/home/mydirectory" } ]</code> </p>
pub fn home_directory_mappings(
&self,
) -> std::option::Option<&[crate::model::HomeDirectoryMapEntry]> {
self.home_directory_mappings.as_deref()
}
/// <p>A session policy for your user so that you can use the same Identity and Access Management (IAM) role across multiple users. This policy scopes down a user's access to portions of their Amazon S3 bucket. Variables that you can use inside this policy include <code>${Transfer:UserName}</code>, <code>${Transfer:HomeDirectory}</code>, and <code>${Transfer:HomeBucket}</code>.</p> <note>
/// <p>This policy applies only when the domain of <code>ServerId</code> is Amazon S3. Amazon EFS does not use session policies.</p>
/// <p>For session policies, Transfer Family stores the policy as a JSON blob, instead of the Amazon Resource Name (ARN) of the policy. You save the policy as a JSON blob and pass it in the <code>Policy</code> argument.</p>
/// <p>For an example of a session policy, see <a href="https://docs.aws.amazon.com/transfer/latest/userguide/session-policy.html">Example session policy</a>.</p>
/// <p>For more information, see <a href="https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html">AssumeRole</a> in the <i>Security Token Service API Reference</i>.</p>
/// </note>
pub fn policy(&self) -> std::option::Option<&str> {
self.policy.as_deref()
}
/// <p>The full POSIX identity, including user ID (<code>Uid</code>), group ID (<code>Gid</code>), and any secondary groups IDs (<code>SecondaryGids</code>), that controls your users' access to your Amazon EFS file systems. The POSIX permissions that are set on files and directories in your file system determine the level of access your users get when transferring files into and out of your Amazon EFS file systems.</p>
pub fn posix_profile(&self) -> std::option::Option<&crate::model::PosixProfile> {
self.posix_profile.as_ref()
}
/// <p>The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that controls your users' access to your Amazon S3 bucket or Amazon EFS file system. The policies attached to this role determine the level of access that you want to provide your users when transferring files into and out of your Amazon S3 bucket or Amazon EFS file system. The IAM role should also contain a trust relationship that allows the server to access your resources when servicing your users' transfer requests.</p>
pub fn role(&self) -> std::option::Option<&str> {
self.role.as_deref()
}
/// <p>A system-assigned unique identifier for a server instance. This is the specific server that you added your user to.</p>
pub fn server_id(&self) -> std::option::Option<&str> {
self.server_id.as_deref()
}
/// <p>A unique identifier that is required to identify specific groups within your directory. The users of the group that you associate have access to your Amazon S3 or Amazon EFS resources over the enabled protocols using Transfer Family. If you know the group name, you can view the SID values by running the following command using Windows PowerShell.</p>
/// <p> <code>Get-ADGroup -Filter {samAccountName -like "<i>YourGroupName</i>*"} -Properties * | Select SamAccountName,ObjectSid</code> </p>
/// <p>In that command, replace <i>YourGroupName</i> with the name of your Active Directory group.</p>
/// <p>The regular expression used to validate this parameter is a string of characters consisting of uppercase and lowercase alphanumeric characters with no spaces. You can also include underscores or any of the following characters: =,.@:/-</p>
pub fn external_id(&self) -> std::option::Option<&str> {
self.external_id.as_deref()
}
}