api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package transfer

import (
	"context"
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
	"github.com/aws/aws-sdk-go-v2/private/protocol"
	"github.com/aws/aws-sdk-go-v2/private/protocol/jsonrpc"
)

const opCreateServer = "CreateServer"

// CreateServerRequest is a API request type for the CreateServer API operation.
type CreateServerRequest struct {
	*aws.Request
	Input *CreateServerInput
	Copy  func(*CreateServerInput) CreateServerRequest
}

// Send marshals and sends the CreateServer API request.
func (r CreateServerRequest) Send(ctx context.Context) (*CreateServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateServerOutput), nil
}

// CreateServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Instantiates an autoscaling virtual server based on Secure File Transfer
// Protocol (SFTP) in AWS. The call returns the ServerId property assigned by
// the service to the newly created server. Reference this ServerId property
// when you make updates to your server, or work with users.
//
// The response returns the ServerId value for the newly created server.
//
//    // Example sending a request using the CreateServerRequest method.
//    req := client.CreateServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateServer
func (c *Transfer) CreateServerRequest(input *CreateServerInput) CreateServerRequest {
	op := &aws.Operation{
		Name:       opCreateServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateServerInput{}
	}

	output := &CreateServerOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateServerRequest{Request: req, Input: input, Copy: c.CreateServerRequest}
}

const opCreateUser = "CreateUser"

// CreateUserRequest is a API request type for the CreateUser API operation.
type CreateUserRequest struct {
	*aws.Request
	Input *CreateUserInput
	Copy  func(*CreateUserInput) CreateUserRequest
}

// Send marshals and sends the CreateUser API request.
func (r CreateUserRequest) Send(ctx context.Context) (*CreateUserOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateUserOutput), nil
}

// CreateUserRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Adds a user and associate them with an existing Secure File Transfer Protocol
// (SFTP) server. Using parameters for CreateUser, you can specify the user
// name, set the home directory, store the user's public key, and assign the
// user's AWS Identity and Access Management (IAM) role. You can also optionally
// add a scope-down policy, and assign metadata with tags that can be used to
// group and search for users.
//
// The response returns the UserName and ServerId values of the new user for
// that server.
//
//    // Example sending a request using the CreateUserRequest method.
//    req := client.CreateUserRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateUser
func (c *Transfer) CreateUserRequest(input *CreateUserInput) CreateUserRequest {
	op := &aws.Operation{
		Name:       opCreateUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateUserInput{}
	}

	output := &CreateUserOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateUserRequest{Request: req, Input: input, Copy: c.CreateUserRequest}
}

const opDeleteServer = "DeleteServer"

// DeleteServerRequest is a API request type for the DeleteServer API operation.
type DeleteServerRequest struct {
	*aws.Request
	Input *DeleteServerInput
	Copy  func(*DeleteServerInput) DeleteServerRequest
}

// Send marshals and sends the DeleteServer API request.
func (r DeleteServerRequest) Send(ctx context.Context) (*DeleteServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteServerOutput), nil
}

// DeleteServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Deletes the Secure File Transfer Protocol (SFTP) server that you specify.
// If you used SERVICE_MANAGED as your IdentityProviderType, you need to delete
// all users associated with this server before deleting the server itself
//
// No response returns from this call.
//
//    // Example sending a request using the DeleteServerRequest method.
//    req := client.DeleteServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteServer
func (c *Transfer) DeleteServerRequest(input *DeleteServerInput) DeleteServerRequest {
	op := &aws.Operation{
		Name:       opDeleteServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteServerInput{}
	}

	output := &DeleteServerOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteServerRequest{Request: req, Input: input, Copy: c.DeleteServerRequest}
}

const opDeleteSshPublicKey = "DeleteSshPublicKey"

// DeleteSshPublicKeyRequest is a API request type for the DeleteSshPublicKey API operation.
type DeleteSshPublicKeyRequest struct {
	*aws.Request
	Input *DeleteSshPublicKeyInput
	Copy  func(*DeleteSshPublicKeyInput) DeleteSshPublicKeyRequest
}

// Send marshals and sends the DeleteSshPublicKey API request.
func (r DeleteSshPublicKeyRequest) Send(ctx context.Context) (*DeleteSshPublicKeyOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteSshPublicKeyOutput), nil
}

// DeleteSshPublicKeyRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Deletes a user's Secure Shell (SSH) public key.
//
// No response is returned from this call.
//
//    // Example sending a request using the DeleteSshPublicKeyRequest method.
//    req := client.DeleteSshPublicKeyRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteSshPublicKey
func (c *Transfer) DeleteSshPublicKeyRequest(input *DeleteSshPublicKeyInput) DeleteSshPublicKeyRequest {
	op := &aws.Operation{
		Name:       opDeleteSshPublicKey,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSshPublicKeyInput{}
	}

	output := &DeleteSshPublicKeyOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteSshPublicKeyRequest{Request: req, Input: input, Copy: c.DeleteSshPublicKeyRequest}
}

const opDeleteUser = "DeleteUser"

// DeleteUserRequest is a API request type for the DeleteUser API operation.
type DeleteUserRequest struct {
	*aws.Request
	Input *DeleteUserInput
	Copy  func(*DeleteUserInput) DeleteUserRequest
}

// Send marshals and sends the DeleteUser API request.
func (r DeleteUserRequest) Send(ctx context.Context) (*DeleteUserOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteUserOutput), nil
}

// DeleteUserRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Deletes the user belonging to the server you specify.
//
// No response returns from this call.
//
// When you delete a user from a server, the user's information is lost.
//
//    // Example sending a request using the DeleteUserRequest method.
//    req := client.DeleteUserRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteUser
func (c *Transfer) DeleteUserRequest(input *DeleteUserInput) DeleteUserRequest {
	op := &aws.Operation{
		Name:       opDeleteUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteUserInput{}
	}

	output := &DeleteUserOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteUserRequest{Request: req, Input: input, Copy: c.DeleteUserRequest}
}

const opDescribeServer = "DescribeServer"

// DescribeServerRequest is a API request type for the DescribeServer API operation.
type DescribeServerRequest struct {
	*aws.Request
	Input *DescribeServerInput
	Copy  func(*DescribeServerInput) DescribeServerRequest
}

// Send marshals and sends the DescribeServer API request.
func (r DescribeServerRequest) Send(ctx context.Context) (*DescribeServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeServerOutput), nil
}

// DescribeServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Describes the server that you specify by passing the ServerId parameter.
//
// The response contains a description of the server's properties.
//
//    // Example sending a request using the DescribeServerRequest method.
//    req := client.DescribeServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeServer
func (c *Transfer) DescribeServerRequest(input *DescribeServerInput) DescribeServerRequest {
	op := &aws.Operation{
		Name:       opDescribeServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeServerInput{}
	}

	output := &DescribeServerOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeServerRequest{Request: req, Input: input, Copy: c.DescribeServerRequest}
}

const opDescribeUser = "DescribeUser"

// DescribeUserRequest is a API request type for the DescribeUser API operation.
type DescribeUserRequest struct {
	*aws.Request
	Input *DescribeUserInput
	Copy  func(*DescribeUserInput) DescribeUserRequest
}

// Send marshals and sends the DescribeUser API request.
func (r DescribeUserRequest) Send(ctx context.Context) (*DescribeUserOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DescribeUserOutput), nil
}

// DescribeUserRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Describes the user assigned to a specific server, as identified by its ServerId
// property.
//
// The response from this call returns the properties of the user associated
// with the ServerId value that was specified.
//
//    // Example sending a request using the DescribeUserRequest method.
//    req := client.DescribeUserRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeUser
func (c *Transfer) DescribeUserRequest(input *DescribeUserInput) DescribeUserRequest {
	op := &aws.Operation{
		Name:       opDescribeUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeUserInput{}
	}

	output := &DescribeUserOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DescribeUserRequest{Request: req, Input: input, Copy: c.DescribeUserRequest}
}

const opImportSshPublicKey = "ImportSshPublicKey"

// ImportSshPublicKeyRequest is a API request type for the ImportSshPublicKey API operation.
type ImportSshPublicKeyRequest struct {
	*aws.Request
	Input *ImportSshPublicKeyInput
	Copy  func(*ImportSshPublicKeyInput) ImportSshPublicKeyRequest
}

// Send marshals and sends the ImportSshPublicKey API request.
func (r ImportSshPublicKeyRequest) Send(ctx context.Context) (*ImportSshPublicKeyOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ImportSshPublicKeyOutput), nil
}

// ImportSshPublicKeyRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Adds a Secure Shell (SSH) public key to a user account identified by a UserName
// value assigned to a specific server, identified by ServerId.
//
// The response returns the UserName value, the ServerId value, and the name
// of the SshPublicKeyId.
//
//    // Example sending a request using the ImportSshPublicKeyRequest method.
//    req := client.ImportSshPublicKeyRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ImportSshPublicKey
func (c *Transfer) ImportSshPublicKeyRequest(input *ImportSshPublicKeyInput) ImportSshPublicKeyRequest {
	op := &aws.Operation{
		Name:       opImportSshPublicKey,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ImportSshPublicKeyInput{}
	}

	output := &ImportSshPublicKeyOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ImportSshPublicKeyRequest{Request: req, Input: input, Copy: c.ImportSshPublicKeyRequest}
}

const opListServers = "ListServers"

// ListServersRequest is a API request type for the ListServers API operation.
type ListServersRequest struct {
	*aws.Request
	Input *ListServersInput
	Copy  func(*ListServersInput) ListServersRequest
}

// Send marshals and sends the ListServers API request.
func (r ListServersRequest) Send(ctx context.Context) (*ListServersOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListServersOutput), nil
}

// ListServersRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Lists the Secure File Transfer Protocol (SFTP) servers that are associated
// with your AWS account.
//
//    // Example sending a request using the ListServersRequest method.
//    req := client.ListServersRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListServers
func (c *Transfer) ListServersRequest(input *ListServersInput) ListServersRequest {
	op := &aws.Operation{
		Name:       opListServers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListServersInput{}
	}

	output := &ListServersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListServersRequest{Request: req, Input: input, Copy: c.ListServersRequest}
}

const opListTagsForResource = "ListTagsForResource"

// ListTagsForResourceRequest is a API request type for the ListTagsForResource API operation.
type ListTagsForResourceRequest struct {
	*aws.Request
	Input *ListTagsForResourceInput
	Copy  func(*ListTagsForResourceInput) ListTagsForResourceRequest
}

// Send marshals and sends the ListTagsForResource API request.
func (r ListTagsForResourceRequest) Send(ctx context.Context) (*ListTagsForResourceOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListTagsForResourceOutput), nil
}

// ListTagsForResourceRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Lists all of the tags associated with the Amazon Resource Number (ARN) you
// specify. The resource can be a user, server, or role.
//
//    // Example sending a request using the ListTagsForResourceRequest method.
//    req := client.ListTagsForResourceRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListTagsForResource
func (c *Transfer) ListTagsForResourceRequest(input *ListTagsForResourceInput) ListTagsForResourceRequest {
	op := &aws.Operation{
		Name:       opListTagsForResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListTagsForResourceInput{}
	}

	output := &ListTagsForResourceOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListTagsForResourceRequest{Request: req, Input: input, Copy: c.ListTagsForResourceRequest}
}

const opListUsers = "ListUsers"

// ListUsersRequest is a API request type for the ListUsers API operation.
type ListUsersRequest struct {
	*aws.Request
	Input *ListUsersInput
	Copy  func(*ListUsersInput) ListUsersRequest
}

// Send marshals and sends the ListUsers API request.
func (r ListUsersRequest) Send(ctx context.Context) (*ListUsersOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListUsersOutput), nil
}

// ListUsersRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Lists the users for the server that you specify by passing the ServerId parameter.
//
//    // Example sending a request using the ListUsersRequest method.
//    req := client.ListUsersRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListUsers
func (c *Transfer) ListUsersRequest(input *ListUsersInput) ListUsersRequest {
	op := &aws.Operation{
		Name:       opListUsers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListUsersInput{}
	}

	output := &ListUsersOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListUsersRequest{Request: req, Input: input, Copy: c.ListUsersRequest}
}

const opStartServer = "StartServer"

// StartServerRequest is a API request type for the StartServer API operation.
type StartServerRequest struct {
	*aws.Request
	Input *StartServerInput
	Copy  func(*StartServerInput) StartServerRequest
}

// Send marshals and sends the StartServer API request.
func (r StartServerRequest) Send(ctx context.Context) (*StartServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*StartServerOutput), nil
}

// StartServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Changes the state of a Secure File Transfer Protocol (SFTP) server from OFFLINE
// to ONLINE. It has no impact on an SFTP server that is already ONLINE. An
// ONLINE server can accept and process file transfer jobs.
//
// The state of STARTING indicates that the server is in an intermediate state,
// either not fully able to respond, or not fully online. The values of START_FAILED
// can indicate an error condition.
//
// No response is returned from this call.
//
//    // Example sending a request using the StartServerRequest method.
//    req := client.StartServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StartServer
func (c *Transfer) StartServerRequest(input *StartServerInput) StartServerRequest {
	op := &aws.Operation{
		Name:       opStartServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartServerInput{}
	}

	output := &StartServerOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return StartServerRequest{Request: req, Input: input, Copy: c.StartServerRequest}
}

const opStopServer = "StopServer"

// StopServerRequest is a API request type for the StopServer API operation.
type StopServerRequest struct {
	*aws.Request
	Input *StopServerInput
	Copy  func(*StopServerInput) StopServerRequest
}

// Send marshals and sends the StopServer API request.
func (r StopServerRequest) Send(ctx context.Context) (*StopServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*StopServerOutput), nil
}

// StopServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Changes the state of an SFTP server from ONLINE to OFFLINE. An OFFLINE server
// cannot accept and process file transfer jobs. Information tied to your server
// such as server and user properties are not affected by stopping your server.
// Stopping a server will not reduce or impact your Secure File Transfer Protocol
// (SFTP) endpoint billing.
//
// The states of STOPPING indicates that the server is in an intermediate state,
// either not fully able to respond, or not fully offline. The values of STOP_FAILED
// can indicate an error condition.
//
// No response is returned from this call.
//
//    // Example sending a request using the StopServerRequest method.
//    req := client.StopServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StopServer
func (c *Transfer) StopServerRequest(input *StopServerInput) StopServerRequest {
	op := &aws.Operation{
		Name:       opStopServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopServerInput{}
	}

	output := &StopServerOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return StopServerRequest{Request: req, Input: input, Copy: c.StopServerRequest}
}

const opTagResource = "TagResource"

// TagResourceRequest is a API request type for the TagResource API operation.
type TagResourceRequest struct {
	*aws.Request
	Input *TagResourceInput
	Copy  func(*TagResourceInput) TagResourceRequest
}

// Send marshals and sends the TagResource API request.
func (r TagResourceRequest) Send(ctx context.Context) (*TagResourceOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*TagResourceOutput), nil
}

// TagResourceRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Attaches a key-value pair to a resource, as identified by its Amazon Resource
// Name (ARN). Resources are users, servers, roles, and other entities.
//
// There is no response returned from this call.
//
//    // Example sending a request using the TagResourceRequest method.
//    req := client.TagResourceRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TagResource
func (c *Transfer) TagResourceRequest(input *TagResourceInput) TagResourceRequest {
	op := &aws.Operation{
		Name:       opTagResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &TagResourceInput{}
	}

	output := &TagResourceOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return TagResourceRequest{Request: req, Input: input, Copy: c.TagResourceRequest}
}

const opTestIdentityProvider = "TestIdentityProvider"

// TestIdentityProviderRequest is a API request type for the TestIdentityProvider API operation.
type TestIdentityProviderRequest struct {
	*aws.Request
	Input *TestIdentityProviderInput
	Copy  func(*TestIdentityProviderInput) TestIdentityProviderRequest
}

// Send marshals and sends the TestIdentityProvider API request.
func (r TestIdentityProviderRequest) Send(ctx context.Context) (*TestIdentityProviderOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*TestIdentityProviderOutput), nil
}

// TestIdentityProviderRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// If the IdentityProviderType of the server is API_Gateway, tests whether your
// API Gateway is set up successfully. We highly recommend that you call this
// method to test your authentication method as soon as you create your server.
// By doing so, you can troubleshoot issues with the API Gateway integration
// to ensure that your users can successfully use the service.
//
//    // Example sending a request using the TestIdentityProviderRequest method.
//    req := client.TestIdentityProviderRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TestIdentityProvider
func (c *Transfer) TestIdentityProviderRequest(input *TestIdentityProviderInput) TestIdentityProviderRequest {
	op := &aws.Operation{
		Name:       opTestIdentityProvider,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &TestIdentityProviderInput{}
	}

	output := &TestIdentityProviderOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return TestIdentityProviderRequest{Request: req, Input: input, Copy: c.TestIdentityProviderRequest}
}

const opUntagResource = "UntagResource"

// UntagResourceRequest is a API request type for the UntagResource API operation.
type UntagResourceRequest struct {
	*aws.Request
	Input *UntagResourceInput
	Copy  func(*UntagResourceInput) UntagResourceRequest
}

// Send marshals and sends the UntagResource API request.
func (r UntagResourceRequest) Send(ctx context.Context) (*UntagResourceOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UntagResourceOutput), nil
}

// UntagResourceRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Detaches a key-value pair from a resource, as identified by its Amazon Resource
// Name (ARN). Resources are users, servers, roles, and other entities.
//
// No response is returned from this call.
//
//    // Example sending a request using the UntagResourceRequest method.
//    req := client.UntagResourceRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UntagResource
func (c *Transfer) UntagResourceRequest(input *UntagResourceInput) UntagResourceRequest {
	op := &aws.Operation{
		Name:       opUntagResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UntagResourceInput{}
	}

	output := &UntagResourceOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(jsonrpc.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}

	return UntagResourceRequest{Request: req, Input: input, Copy: c.UntagResourceRequest}
}

const opUpdateServer = "UpdateServer"

// UpdateServerRequest is a API request type for the UpdateServer API operation.
type UpdateServerRequest struct {
	*aws.Request
	Input *UpdateServerInput
	Copy  func(*UpdateServerInput) UpdateServerRequest
}

// Send marshals and sends the UpdateServer API request.
func (r UpdateServerRequest) Send(ctx context.Context) (*UpdateServerOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateServerOutput), nil
}

// UpdateServerRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Updates the server properties after that server has been created.
//
// The UpdateServer call returns the ServerId of the Secure File Transfer Protocol
// (SFTP) server you updated.
//
//    // Example sending a request using the UpdateServerRequest method.
//    req := client.UpdateServerRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateServer
func (c *Transfer) UpdateServerRequest(input *UpdateServerInput) UpdateServerRequest {
	op := &aws.Operation{
		Name:       opUpdateServer,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateServerInput{}
	}

	output := &UpdateServerOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateServerRequest{Request: req, Input: input, Copy: c.UpdateServerRequest}
}

const opUpdateUser = "UpdateUser"

// UpdateUserRequest is a API request type for the UpdateUser API operation.
type UpdateUserRequest struct {
	*aws.Request
	Input *UpdateUserInput
	Copy  func(*UpdateUserInput) UpdateUserRequest
}

// Send marshals and sends the UpdateUser API request.
func (r UpdateUserRequest) Send(ctx context.Context) (*UpdateUserOutput, error) {
	r.Request.SetContext(ctx)
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateUserOutput), nil
}

// UpdateUserRequest returns a request value for making API operation for
// AWS Transfer for SFTP.
//
// Assigns new properties to a user. Parameters you pass modify any or all of
// the following: the home directory, role, and policy for the UserName and
// ServerId you specify.
//
// The response returns the ServerId and the UserName for the updated user.
//
//    // Example sending a request using the UpdateUserRequest method.
//    req := client.UpdateUserRequest(params)
//    resp, err := req.Send(context.TODO())
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateUser
func (c *Transfer) UpdateUserRequest(input *UpdateUserInput) UpdateUserRequest {
	op := &aws.Operation{
		Name:       opUpdateUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateUserInput{}
	}

	output := &UpdateUserOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateUserRequest{Request: req, Input: input, Copy: c.UpdateUserRequest}
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateServerRequest
type CreateServerInput struct {
	_ struct{} `type:"structure"`

	EndpointDetails *EndpointDetails `type:"structure"`

	EndpointType EndpointType `type:"string" enum:"true"`

	// An array containing all of the information required to call a customer-supplied
	// authentication API. This parameter is not required when the IdentityProviderType
	// value of server that is created uses the SERVICE_MANAGED authentication method.
	IdentityProviderDetails *IdentityProviderDetails `type:"structure"`

	// The mode of authentication enabled for this service. The default value is
	// SERVICE_MANAGED, which allows you to store and access SFTP user credentials
	// within the service. An IdentityProviderType value of API_GATEWAY indicates
	// that user authentication requires a call to an API Gateway endpoint URL provided
	// by you to integrate an identity provider of your choice.
	IdentityProviderType IdentityProviderType `type:"string" enum:"true"`

	// A value that allows the service to write your SFTP users' activity to your
	// Amazon CloudWatch logs for monitoring and auditing purposes.
	LoggingRole *string `type:"string"`

	// Key-value pairs that can be used to group and search for servers.
	Tags []Tag `min:"1" type:"list"`
}

// String returns the string representation
func (s CreateServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateServerInput"}
	if s.Tags != nil && len(s.Tags) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Tags", 1))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateServerResponse
type CreateServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The service-assigned ID of the SFTP server that is created.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s CreateServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateUserRequest
type CreateUserInput struct {
	_ struct{} `type:"structure"`

	// The landing directory (folder) for a user when they log in to the server
	// using their SFTP client. An example is /home/username.
	HomeDirectory *string `type:"string"`

	// A scope-down policy for your user so you can use the same IAM role across
	// multiple users. This policy scopes down user access to portions of their
	// Amazon S3 bucket. Variables you can use inside this policy include ${Transfer:UserName},
	// ${Transfer:HomeDirectory}, and ${Transfer:HomeBucket}.
	Policy *string `type:"string"`

	// The IAM role that controls your user's access to your Amazon S3 bucket. The
	// policies attached to this role will determine the level of access you want
	// to provide your users when transferring files into and out of your Amazon
	// S3 bucket or buckets. The IAM role should also contain a trust relationship
	// that allows the SFTP server to access your resources when servicing your
	// SFTP user's transfer requests.
	//
	// Role is a required field
	Role *string `type:"string" required:"true"`

	// A system-assigned unique identifier for an SFTP server instance. This is
	// the specific SFTP server that you added your user to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// The public portion of the Secure Shall (SSH) key used to authenticate the
	// user to the SFTP server.
	SshPublicKeyBody *string `type:"string"`

	// Key-value pairs that can be used to group and search for users. Tags are
	// metadata attached to users for any purpose.
	Tags []Tag `min:"1" type:"list"`

	// A unique string that identifies a user and is associated with a server as
	// specified by the ServerId.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s CreateUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateUserInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateUserInput"}

	if s.Role == nil {
		invalidParams.Add(aws.NewErrParamRequired("Role"))
	}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}
	if s.Tags != nil && len(s.Tags) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Tags", 1))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateUserResponse
type CreateUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ID of the SFTP server that the user is attached to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// A unique string that identifies a user account associated with an SFTP server.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s CreateUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateUserOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateUserOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteServerRequest
type DeleteServerInput struct {
	_ struct{} `type:"structure"`

	// A unique system-assigned identifier for an SFTP server instance.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteServerInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteServerOutput
type DeleteServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteSshPublicKeyRequest
type DeleteSshPublicKeyInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for a Secure File Transfer Protocol (SFTP)
	// server instance that has the user assigned to it.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// A unique identifier used to reference your user's specific SSH key.
	//
	// SshPublicKeyId is a required field
	SshPublicKeyId *string `type:"string" required:"true"`

	// A unique string that identifies a user whose public key is being deleted.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteSshPublicKeyInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSshPublicKeyInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSshPublicKeyInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteSshPublicKeyInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.SshPublicKeyId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SshPublicKeyId"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteSshPublicKeyOutput
type DeleteSshPublicKeyOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteSshPublicKeyOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSshPublicKeyOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteSshPublicKeyOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteUserRequest
type DeleteUserInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server instance that has
	// the user assigned to it.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// A unique string that identifies a user that is being deleted from the server.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteUserInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteUserInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DeleteUserOutput
type DeleteUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s DeleteUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteUserOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteUserOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeServerRequest
type DescribeServerInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeServerInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeServerResponse
type DescribeServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array containing the properties of the server with the ServerID you specified.
	//
	// Server is a required field
	Server *DescribedServer `type:"structure" required:"true"`
}

// String returns the string representation
func (s DescribeServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeUserRequest
type DescribeUserInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server that has this user
	// assigned.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// The name of the user assigned to one or more servers. User names are part
	// of the sign-in credentials to use the AWS Transfer service and perform file
	// transfer tasks.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s DescribeUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeUserInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeUserInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribeUserResponse
type DescribeUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A system-assigned unique identifier for an SFTP server that has this user
	// assigned.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// An array containing the properties of the user account for the ServerID value
	// that you specified.
	//
	// User is a required field
	User *DescribedUser `type:"structure" required:"true"`
}

// String returns the string representation
func (s DescribeUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribeUserOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DescribeUserOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Describe the properties of the server that was specified. Information returned
// includes: the server Amazon Resource Name (ARN), the authentication configuration
// and type, the logging role, server Id and state, and assigned tags or metadata.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribedServer
type DescribedServer struct {
	_ struct{} `type:"structure"`

	// Specifies the unique Amazon Resource Name (ARN) for the server to be described.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	EndpointDetails *EndpointDetails `type:"structure"`

	EndpointType EndpointType `type:"string" enum:"true"`

	// Specifies information to call a customer-supplied authentication API. This
	// field is not populated when the IdentityProviderType of the server is SERVICE_MANAGED>.
	IdentityProviderDetails *IdentityProviderDetails `type:"structure"`

	// This property defines the mode of authentication method enabled for this
	// service. A value of SERVICE_MANAGED, means that you are using this Server
	// to store and access SFTP user credentials within the service. A value of
	// API_GATEWAY indicates that you have integrated an API Gateway endpoint that
	// will be invoked for authenticating your user into the service.
	IdentityProviderType IdentityProviderType `type:"string" enum:"true"`

	// This property is an AWS Identity and Access Management (IAM) entity that
	// allows the server to turn on Amazon CloudWatch logging for Amazon S3 events.
	// When set, user activity can be view in your CloudWatch logs.
	LoggingRole *string `type:"string"`

	// This property is a unique system assigned identifier for the SFTP server
	// that you instantiate.
	ServerId *string `type:"string"`

	// The condition of the SFTP server for the server that was described. A value
	// of ONLINE indicates that the server can accept jobs and transfer files. A
	// State value of OFFLINE means that the server cannot perform file transfer
	// operations.
	//
	// The states of STARTING and STOPPING indicated that the server is in an intermediate
	// state, either not fully able to respond, or not fully offline. The values
	// of START_FAILED or STOP_FAILED can indicate an error condition.
	State State `type:"string" enum:"true"`

	// This property contains the key-value pairs that you can use to search for
	// and group servers that were assigned to the server that was described.
	Tags []Tag `min:"1" type:"list"`

	// The number of users that are assigned to the SFTP server you specified with
	// the ServerId.
	UserCount *int64 `type:"integer"`
}

// String returns the string representation
func (s DescribedServer) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribedServer) GoString() string {
	return s.String()
}

// Returns properties of the user that you wish to describe.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/DescribedUser
type DescribedUser struct {
	_ struct{} `type:"structure"`

	// This property contains the unique Amazon Resource Name (ARN) for the user
	// that was requested to be described.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	// This property specifies the landing directory (or folder) which is the location
	// that files are written to or read from in an Amazon S3 bucket for the described
	// user. An example would be: /bucket_name/home/username.
	HomeDirectory *string `type:"string"`

	// Specifies the name of the policy in use for the described user.
	Policy *string `type:"string"`

	// This property specifies the IAM role that controls your user's access to
	// your Amazon S3 bucket. The policies attached to this role will determine
	// the level of access you want to provide your users when transferring files
	// into and out of your Amazon S3 bucket or buckets. The IAM role should also
	// contain a trust relationship that allows the SFTP server to access your resources
	// when servicing your SFTP user's transfer requests.
	Role *string `type:"string"`

	// This property contains the public key portion of the Secure Shell (SSH) keys
	// stored for the described user.
	SshPublicKeys []SshPublicKey `type:"list"`

	// This property contains the key-value pairs for the user requested. Tag can
	// be used to search for and group users for a variety of purposes.
	Tags []Tag `min:"1" type:"list"`

	// This property is the name of the user that was requested to be described.
	// User names are used for authentication purposes. This is the string that
	// will be used by your user when they log in to your SFTP server.
	UserName *string `type:"string"`
}

// String returns the string representation
func (s DescribedUser) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DescribedUser) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/EndpointDetails
type EndpointDetails struct {
	_ struct{} `type:"structure"`

	VpcEndpointId *string `type:"string"`
}

// String returns the string representation
func (s EndpointDetails) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s EndpointDetails) GoString() string {
	return s.String()
}

// Returns information related to the type of user authentication that is in
// use for a server's users. A server can only have one method of authentication.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/IdentityProviderDetails
type IdentityProviderDetails struct {
	_ struct{} `type:"structure"`

	// The Role parameter provides the type of InvocationRole used to authenticate
	// the user account.
	InvocationRole *string `type:"string"`

	// The IdentityProviderDetail parameter contains the location of the service
	// endpoint used to authenticate users.
	Url *string `type:"string"`
}

// String returns the string representation
func (s IdentityProviderDetails) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IdentityProviderDetails) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ImportSshPublicKeyRequest
type ImportSshPublicKeyInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// The public key portion of an SSH key pair.
	//
	// SshPublicKeyBody is a required field
	SshPublicKeyBody *string `type:"string" required:"true"`

	// The name of the user account that is assigned to one or more servers.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ImportSshPublicKeyInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ImportSshPublicKeyInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ImportSshPublicKeyInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ImportSshPublicKeyInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.SshPublicKeyBody == nil {
		invalidParams.Add(aws.NewErrParamRequired("SshPublicKeyBody"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// This response identifies the user, server they belong to, and the identifier
// of the SSH public key associated with that user. A user can have more than
// one key on each server that they are associate with.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ImportSshPublicKeyResponse
type ImportSshPublicKeyOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A system-assigned unique identifier for an SFTP server.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// This identifier is the name given to a public key by the system that was
	// imported.
	//
	// SshPublicKeyId is a required field
	SshPublicKeyId *string `type:"string" required:"true"`

	// A user name assigned to the ServerID value that you specified.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ImportSshPublicKeyOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ImportSshPublicKeyOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ImportSshPublicKeyOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListServersRequest
type ListServersInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of servers to return as a response to the ListServers
	// query.
	MaxResults *int64 `min:"1" type:"integer"`

	// When additional results are obtained from the ListServers command, a NextToken
	// parameter is returned in the output. You can then pass the NextToken parameter
	// in a subsequent command to continue listing additional servers.
	NextToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListServersInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListServersInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListServersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListServersInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListServersResponse
type ListServersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// When you can get additional results from the ListServers operation, a NextToken
	// parameter is returned in the output. In a following command, you can pass
	// in the NextToken parameter to continue listing additional servers.
	NextToken *string `min:"1" type:"string"`

	// An array of servers that were listed.
	//
	// Servers is a required field
	Servers []ListedServer `type:"list" required:"true"`
}

// String returns the string representation
func (s ListServersOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListServersOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListServersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListTagsForResourceRequest
type ListTagsForResourceInput struct {
	_ struct{} `type:"structure"`

	// Requests the tags associated with a particular Amazon Resource Name (ARN).
	// An ARN is an identifier for a specific AWS resource, such as a server, user,
	// or role.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	// Specifies the number of tags to return as a response to the ListTagsForResource
	// request.
	MaxResults *int64 `min:"1" type:"integer"`

	// When you request additional results from the ListTagsForResource call, a
	// NextToken parameter is returned in the input. You can then pass in a subsequent
	// command the NextToken parameter to continue listing additional tags.
	NextToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListTagsForResourceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTagsForResourceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListTagsForResourceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListTagsForResourceInput"}

	if s.Arn == nil {
		invalidParams.Add(aws.NewErrParamRequired("Arn"))
	}
	if s.Arn != nil && len(*s.Arn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("Arn", 20))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListTagsForResourceResponse
type ListTagsForResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// This value is the ARN you specified to list the tags of.
	Arn *string `min:"20" type:"string"`

	// When you can get additional results from the ListTagsForResource call, a
	// NextToken parameter is returned in the output. You can then pass in a subsequent
	// command the NextToken parameter to continue listing additional tags.
	NextToken *string `min:"1" type:"string"`

	// Key-value pairs that are assigned to a resource, usually for the purpose
	// of grouping and searching for items. Tags are metadata that you define that
	// you can use for any purpose.
	Tags []Tag `min:"1" type:"list"`
}

// String returns the string representation
func (s ListTagsForResourceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListTagsForResourceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListTagsForResourceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListUsersRequest
type ListUsersInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of users to return as a response to the ListUsers request.
	MaxResults *int64 `min:"1" type:"integer"`

	// When you can get additional results from the ListUsers call, a NextToken
	// parameter is returned in the output. You can then pass in a subsequent command
	// the NextToken parameter to continue listing additional users.
	NextToken *string `min:"1" type:"string"`

	// A system-assigned unique identifier for a Secure File Transfer Protocol (SFTP)
	// server that has users are assigned to it.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s ListUsersInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUsersInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListUsersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListUsersInput"}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextToken", 1))
	}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListUsersResponse
type ListUsersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// When you can get additional results from the ListUsers call, a NextToken
	// parameter is returned in the output. You can then pass in a subsequent command
	// the NextToken parameter to continue listing additional users.
	NextToken *string `min:"1" type:"string"`

	// A system-assigned unique identifier for an SFTP server that the users are
	// assigned to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// Returns the user accounts and their properties for the ServerId value that
	// you specify.
	//
	// Users is a required field
	Users []ListedUser `type:"list" required:"true"`
}

// String returns the string representation
func (s ListUsersOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListUsersOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListUsersOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Returns properties of the server that was specified.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListedServer
type ListedServer struct {
	_ struct{} `type:"structure"`

	// The unique Amazon Resource Name (ARN) for the server to be listed.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	EndpointType EndpointType `type:"string" enum:"true"`

	// The authentication method used to validate a user for the server that was
	// specified. listed. This can include Secure Shell (SSH), user name and password
	// combinations, or your own custom authentication method. Valid values include
	// SERVICE_MANAGED or API_GATEWAY.
	IdentityProviderType IdentityProviderType `type:"string" enum:"true"`

	// The AWS Identity and Access Management entity that allows the server to turn
	// on Amazon CloudWatch logging.
	LoggingRole *string `type:"string"`

	// This value is the unique system assigned identifier for the SFTP servers
	// that were listed.
	ServerId *string `type:"string"`

	// This property describes the condition of the SFTP server for the server that
	// was described. A value of ONLINE> indicates that the server can accept jobs
	// and transfer files. A State value of OFFLINE means that the server cannot
	// perform file transfer operations.
	//
	// The states of STARTING and STOPPING indicated that the server is in an intermediate
	// state, either not fully able to respond, or not fully offline. The values
	// of START_FAILED or STOP_FAILED can indicate an error condition.
	State State `type:"string" enum:"true"`

	// This property is a numeric value that indicates the number of users that
	// are assigned to the SFTP server you specified with the ServerId.
	UserCount *int64 `type:"integer"`
}

// String returns the string representation
func (s ListedServer) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListedServer) GoString() string {
	return s.String()
}

// Returns properties of the user that you specify.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/ListedUser
type ListedUser struct {
	_ struct{} `type:"structure"`

	// This property is the unique Amazon Resource Name (ARN) for the user that
	// you wish to learn about.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	// This value specifies the location that files are written to or read from
	// an Amazon S3 bucket for the user you specify by their ARN.
	HomeDirectory *string `type:"string"`

	// The role in use by this user. A role is an AWS Identity and Access Management
	// (IAM) entity that in this case allows the SFTP server to act on a user's
	// behalf. It allows the server to inherit the trust relationship that enables
	// that user to perform file operations to their Amazon S3 bucket.
	Role *string `type:"string"`

	// This value is the number of SSH public keys stored for the user you specified.
	SshPublicKeyCount *int64 `type:"integer"`

	// The name of the user whose ARN was specified. User names are used for authentication
	// purposes.
	UserName *string `type:"string"`
}

// String returns the string representation
func (s ListedUser) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListedUser) GoString() string {
	return s.String()
}

// Provides information about the public Secure Shell (SSH) key that is associated
// with a user account for a specific server (as identified by ServerId). The
// information returned includes the date the key was imported, the public key
// contents, and the public key ID. A user can store more than one SSH public
// key associated with their user name on a specific SFTP server.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/SshPublicKey
type SshPublicKey struct {
	_ struct{} `type:"structure"`

	// The date that the public key was added to the user account.
	//
	// DateImported is a required field
	DateImported *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The content of the SSH public key as specified by the PublicKeyId.
	//
	// SshPublicKeyBody is a required field
	SshPublicKeyBody *string `type:"string" required:"true"`

	// The SshPublicKeyId parameter contains the identifier of the public key.
	//
	// SshPublicKeyId is a required field
	SshPublicKeyId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s SshPublicKey) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SshPublicKey) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StartServerRequest
type StartServerInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server that you start.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s StartServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StartServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StartServerInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StartServerOutput
type StartServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s StartServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s StartServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StopServerRequest
type StopServerInput struct {
	_ struct{} `type:"structure"`

	// A system-assigned unique identifier for an SFTP server that you stopped.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s StopServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StopServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "StopServerInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/StopServerOutput
type StopServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s StopServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StopServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s StopServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Creates a key-value pair for a specific resource. Tags are metadata that
// you can use to search for and group a resource for various purposes. You
// can apply tags to servers, users, and roles. A tag key can take more than
// one value. For example, to group servers for accounting purposes, you might
// create a tag called Group and assign the values Research and Accounting to
// that group.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/Tag
type Tag struct {
	_ struct{} `type:"structure"`

	// The name assigned to the tag that you create.
	//
	// Key is a required field
	Key *string `type:"string" required:"true"`

	// This property contains one or more values that you assigned to the key name
	// you create.
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
}

// String returns the string representation
func (s Tag) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Tag) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Tag) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Tag"}

	if s.Key == nil {
		invalidParams.Add(aws.NewErrParamRequired("Key"))
	}

	if s.Value == nil {
		invalidParams.Add(aws.NewErrParamRequired("Value"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TagResourceRequest
type TagResourceInput struct {
	_ struct{} `type:"structure"`

	// An Amazon Resource Name (ARN) for a specific AWS resource, such as a server,
	// user, or role.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	// 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.
	//
	// Tags is a required field
	Tags []Tag `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s TagResourceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TagResourceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *TagResourceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "TagResourceInput"}

	if s.Arn == nil {
		invalidParams.Add(aws.NewErrParamRequired("Arn"))
	}
	if s.Arn != nil && len(*s.Arn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("Arn", 20))
	}

	if s.Tags == nil {
		invalidParams.Add(aws.NewErrParamRequired("Tags"))
	}
	if s.Tags != nil && len(s.Tags) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Tags", 1))
	}
	if s.Tags != nil {
		for i, v := range s.Tags {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Tags", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TagResourceOutput
type TagResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s TagResourceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TagResourceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s TagResourceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TestIdentityProviderRequest
type TestIdentityProviderInput struct {
	_ struct{} `type:"structure"`

	// A system assigned identifier for a specific server. That server's user authentication
	// method is tested with a user name and password.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// This request parameter is name of the user account to be tested.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`

	// The password of the user account to be tested.
	UserPassword *string `type:"string"`
}

// String returns the string representation
func (s TestIdentityProviderInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TestIdentityProviderInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *TestIdentityProviderInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "TestIdentityProviderInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/TestIdentityProviderResponse
type TestIdentityProviderOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The result of the authorization test as a message.
	Message *string `type:"string"`

	// The HTTP status code that is the response from your API Gateway.
	//
	// StatusCode is a required field
	StatusCode *int64 `type:"integer" required:"true"`

	// The endpoint of the service used to authenticate a user.
	//
	// Url is a required field
	Url *string `type:"string" required:"true"`
}

// String returns the string representation
func (s TestIdentityProviderOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TestIdentityProviderOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s TestIdentityProviderOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UntagResourceRequest
type UntagResourceInput struct {
	_ struct{} `type:"structure"`

	// This is the value of the resource that will have the tag removed. An Amazon
	// Resource Name (ARN) is an identifier for a specific AWS resource, such as
	// a server, user, or role.
	//
	// Arn is a required field
	Arn *string `min:"20" type:"string" required:"true"`

	// 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.
	//
	// TagKeys is a required field
	TagKeys []string `min:"1" type:"list" required:"true"`
}

// String returns the string representation
func (s UntagResourceInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UntagResourceInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UntagResourceInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UntagResourceInput"}

	if s.Arn == nil {
		invalidParams.Add(aws.NewErrParamRequired("Arn"))
	}
	if s.Arn != nil && len(*s.Arn) < 20 {
		invalidParams.Add(aws.NewErrParamMinLen("Arn", 20))
	}

	if s.TagKeys == nil {
		invalidParams.Add(aws.NewErrParamRequired("TagKeys"))
	}
	if s.TagKeys != nil && len(s.TagKeys) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("TagKeys", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UntagResourceOutput
type UntagResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

// String returns the string representation
func (s UntagResourceOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UntagResourceOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UntagResourceOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateServerRequest
type UpdateServerInput struct {
	_ struct{} `type:"structure"`

	EndpointDetails *EndpointDetails `type:"structure"`

	EndpointType EndpointType `type:"string" enum:"true"`

	// This response parameter is an array containing all of the information required
	// to call a customer's authentication API method.
	IdentityProviderDetails *IdentityProviderDetails `type:"structure"`

	// Changes the AWS Identity and Access Management (IAM) role that allows Amazon
	// S3 events to be logged in Amazon CloudWatch, turning logging on or off.
	LoggingRole *string `type:"string"`

	// A system-assigned unique identifier for an SFTP server instance that the
	// user account is assigned to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateServerInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateServerInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateServerInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateServerInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateServerResponse
type UpdateServerOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A system-assigned unique identifier for an SFTP server that the user account
	// is assigned to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateServerOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateServerOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateServerOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateUserRequest
type UpdateUserInput struct {
	_ struct{} `type:"structure"`

	// The HomeDirectory parameter specifies the landing directory (folder) for
	// a user when they log in to the server using their client. An example would
	// be: /home/username.
	HomeDirectory *string `type:"string"`

	// Allows you to supply a scope-down policy for your user so you can use the
	// same AWS Identity and Access Management (IAM) role across multiple users.
	// The policy scopes down users access to portions of your Amazon S3 bucket.
	// Variables you can use inside this policy include ${Transfer:UserName}, ${Transfer:HomeDirectory},
	// and ${Transfer:HomeBucket}.
	Policy *string `type:"string"`

	// The IAM role that controls your user's access to your Amazon S3 bucket. The
	// policies attached to this role will determine the level of access you want
	// to provide your users when transferring files into and out of your Amazon
	// S3 bucket or buckets. The IAM role should also contain a trust relationship
	// that allows the Secure File Transfer Protocol (SFTP) server to access your
	// resources when servicing your SFTP user's transfer requests.
	Role *string `type:"string"`

	// A system-assigned unique identifier for an SFTP server instance that the
	// user account is assigned to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// A unique string that identifies a user and is associated with a server as
	// specified by the ServerId. This is the string that will be used by your user
	// when they log in to your SFTP server.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateUserInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateUserInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateUserInput"}

	if s.ServerId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServerId"))
	}

	if s.UserName == nil {
		invalidParams.Add(aws.NewErrParamRequired("UserName"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// UpdateUserResponse returns the user name and server identifier for the request
// to update a user's properties.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/UpdateUserResponse
type UpdateUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A system-assigned unique identifier for an SFTP server instance that the
	// user account is assigned to.
	//
	// ServerId is a required field
	ServerId *string `type:"string" required:"true"`

	// The unique identifier for a user that is assigned to the SFTP server instance
	// that was specified in the request.
	//
	// UserName is a required field
	UserName *string `type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateUserOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateUserOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateUserOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

type EndpointType string

// Enum values for EndpointType
const (
	EndpointTypePublic      EndpointType = "PUBLIC"
	EndpointTypeVpcEndpoint EndpointType = "VPC_ENDPOINT"
)

func (enum EndpointType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EndpointType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Returns information related to the type of user authentication that is in
// use for a server's users. For SERVICE_MANAGED authentication, the Secure
// Shell (SSH) public keys are stored with a user on an SFTP server instance.
// For API_GATEWAY authentication, your custom authentication method is implemented
// by using an API call. A server can only have one method of authentication.
type IdentityProviderType string

// Enum values for IdentityProviderType
const (
	IdentityProviderTypeServiceManaged IdentityProviderType = "SERVICE_MANAGED"
	IdentityProviderTypeApiGateway     IdentityProviderType = "API_GATEWAY"
)

func (enum IdentityProviderType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum IdentityProviderType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Describes the condition of the SFTP server with respect to its ability to
// perform file operations. There are six possible states: OFFLINE, ONLINE,
// STARTING, STOPPING, START_FAILED, and STOP_FAILED.
//
// OFFLINE indicates that the SFTP server exists, but that it is not available
// for file operations. ONLINE indicates that the SFTP server is available to
// perform file operations. STARTING indicates that the SFTP server's was instantiated,
// but the server is not yet available to perform file operations. Under normal
// conditions, it can take a couple of minutes for an SFTP server to be completely
// operational. Both START_FAILED and STOP_FAILED are error conditions.
type State string

// Enum values for State
const (
	StateOffline     State = "OFFLINE"
	StateOnline      State = "ONLINE"
	StateStarting    State = "STARTING"
	StateStopping    State = "STOPPING"
	StateStartFailed State = "START_FAILED"
	StateStopFailed  State = "STOP_FAILED"
)

func (enum State) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum State) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}