api.go

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

package appstream

import (
	"fmt"
	"time"

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

const opAssociateFleet = "AssociateFleet"

// AssociateFleetRequest is a API request type for the AssociateFleet API operation.
type AssociateFleetRequest struct {
	*aws.Request
	Input *AssociateFleetInput
	Copy  func(*AssociateFleetInput) AssociateFleetRequest
}

// Send marshals and sends the AssociateFleet API request.
func (r AssociateFleetRequest) Send() (*AssociateFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// AssociateFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Associates the specified fleet with the specified stack.
//
//    // Example sending a request using the AssociateFleetRequest method.
//    req := client.AssociateFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/AssociateFleet
func (c *AppStream) AssociateFleetRequest(input *AssociateFleetInput) AssociateFleetRequest {
	op := &aws.Operation{
		Name:       opAssociateFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateFleetInput{}
	}

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

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

const opCopyImage = "CopyImage"

// CopyImageRequest is a API request type for the CopyImage API operation.
type CopyImageRequest struct {
	*aws.Request
	Input *CopyImageInput
	Copy  func(*CopyImageInput) CopyImageRequest
}

// Send marshals and sends the CopyImage API request.
func (r CopyImageRequest) Send() (*CopyImageOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CopyImageRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Copies the image within the same region or to a new region within the same
// AWS account. Note that any tags you added to the image will not be copied.
//
//    // Example sending a request using the CopyImageRequest method.
//    req := client.CopyImageRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CopyImage
func (c *AppStream) CopyImageRequest(input *CopyImageInput) CopyImageRequest {
	op := &aws.Operation{
		Name:       opCopyImage,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CopyImageInput{}
	}

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

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

const opCreateDirectoryConfig = "CreateDirectoryConfig"

// CreateDirectoryConfigRequest is a API request type for the CreateDirectoryConfig API operation.
type CreateDirectoryConfigRequest struct {
	*aws.Request
	Input *CreateDirectoryConfigInput
	Copy  func(*CreateDirectoryConfigInput) CreateDirectoryConfigRequest
}

// Send marshals and sends the CreateDirectoryConfig API request.
func (r CreateDirectoryConfigRequest) Send() (*CreateDirectoryConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateDirectoryConfigRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates a directory configuration.
//
//    // Example sending a request using the CreateDirectoryConfigRequest method.
//    req := client.CreateDirectoryConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateDirectoryConfig
func (c *AppStream) CreateDirectoryConfigRequest(input *CreateDirectoryConfigInput) CreateDirectoryConfigRequest {
	op := &aws.Operation{
		Name:       opCreateDirectoryConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateDirectoryConfigInput{}
	}

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

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

const opCreateFleet = "CreateFleet"

// CreateFleetRequest is a API request type for the CreateFleet API operation.
type CreateFleetRequest struct {
	*aws.Request
	Input *CreateFleetInput
	Copy  func(*CreateFleetInput) CreateFleetRequest
}

// Send marshals and sends the CreateFleet API request.
func (r CreateFleetRequest) Send() (*CreateFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates a fleet.
//
//    // Example sending a request using the CreateFleetRequest method.
//    req := client.CreateFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateFleet
func (c *AppStream) CreateFleetRequest(input *CreateFleetInput) CreateFleetRequest {
	op := &aws.Operation{
		Name:       opCreateFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateFleetInput{}
	}

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

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

const opCreateImageBuilder = "CreateImageBuilder"

// CreateImageBuilderRequest is a API request type for the CreateImageBuilder API operation.
type CreateImageBuilderRequest struct {
	*aws.Request
	Input *CreateImageBuilderInput
	Copy  func(*CreateImageBuilderInput) CreateImageBuilderRequest
}

// Send marshals and sends the CreateImageBuilder API request.
func (r CreateImageBuilderRequest) Send() (*CreateImageBuilderOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateImageBuilderRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates an image builder.
//
// The initial state of the builder is PENDING. When it is ready, the state
// is RUNNING.
//
//    // Example sending a request using the CreateImageBuilderRequest method.
//    req := client.CreateImageBuilderRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilder
func (c *AppStream) CreateImageBuilderRequest(input *CreateImageBuilderInput) CreateImageBuilderRequest {
	op := &aws.Operation{
		Name:       opCreateImageBuilder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateImageBuilderInput{}
	}

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

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

const opCreateImageBuilderStreamingURL = "CreateImageBuilderStreamingURL"

// CreateImageBuilderStreamingURLRequest is a API request type for the CreateImageBuilderStreamingURL API operation.
type CreateImageBuilderStreamingURLRequest struct {
	*aws.Request
	Input *CreateImageBuilderStreamingURLInput
	Copy  func(*CreateImageBuilderStreamingURLInput) CreateImageBuilderStreamingURLRequest
}

// Send marshals and sends the CreateImageBuilderStreamingURL API request.
func (r CreateImageBuilderStreamingURLRequest) Send() (*CreateImageBuilderStreamingURLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateImageBuilderStreamingURLRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates a URL to start an image builder streaming session.
//
//    // Example sending a request using the CreateImageBuilderStreamingURLRequest method.
//    req := client.CreateImageBuilderStreamingURLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilderStreamingURL
func (c *AppStream) CreateImageBuilderStreamingURLRequest(input *CreateImageBuilderStreamingURLInput) CreateImageBuilderStreamingURLRequest {
	op := &aws.Operation{
		Name:       opCreateImageBuilderStreamingURL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateImageBuilderStreamingURLInput{}
	}

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

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

const opCreateStack = "CreateStack"

// CreateStackRequest is a API request type for the CreateStack API operation.
type CreateStackRequest struct {
	*aws.Request
	Input *CreateStackInput
	Copy  func(*CreateStackInput) CreateStackRequest
}

// Send marshals and sends the CreateStack API request.
func (r CreateStackRequest) Send() (*CreateStackOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateStackRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates a stack.
//
//    // Example sending a request using the CreateStackRequest method.
//    req := client.CreateStackRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStack
func (c *AppStream) CreateStackRequest(input *CreateStackInput) CreateStackRequest {
	op := &aws.Operation{
		Name:       opCreateStack,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateStackInput{}
	}

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

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

const opCreateStreamingURL = "CreateStreamingURL"

// CreateStreamingURLRequest is a API request type for the CreateStreamingURL API operation.
type CreateStreamingURLRequest struct {
	*aws.Request
	Input *CreateStreamingURLInput
	Copy  func(*CreateStreamingURLInput) CreateStreamingURLRequest
}

// Send marshals and sends the CreateStreamingURL API request.
func (r CreateStreamingURLRequest) Send() (*CreateStreamingURLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// CreateStreamingURLRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Creates a URL to start a streaming session for the specified user.
//
//    // Example sending a request using the CreateStreamingURLRequest method.
//    req := client.CreateStreamingURLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStreamingURL
func (c *AppStream) CreateStreamingURLRequest(input *CreateStreamingURLInput) CreateStreamingURLRequest {
	op := &aws.Operation{
		Name:       opCreateStreamingURL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateStreamingURLInput{}
	}

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

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

const opDeleteDirectoryConfig = "DeleteDirectoryConfig"

// DeleteDirectoryConfigRequest is a API request type for the DeleteDirectoryConfig API operation.
type DeleteDirectoryConfigRequest struct {
	*aws.Request
	Input *DeleteDirectoryConfigInput
	Copy  func(*DeleteDirectoryConfigInput) DeleteDirectoryConfigRequest
}

// Send marshals and sends the DeleteDirectoryConfig API request.
func (r DeleteDirectoryConfigRequest) Send() (*DeleteDirectoryConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DeleteDirectoryConfigRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Deletes the specified directory configuration.
//
//    // Example sending a request using the DeleteDirectoryConfigRequest method.
//    req := client.DeleteDirectoryConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteDirectoryConfig
func (c *AppStream) DeleteDirectoryConfigRequest(input *DeleteDirectoryConfigInput) DeleteDirectoryConfigRequest {
	op := &aws.Operation{
		Name:       opDeleteDirectoryConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteDirectoryConfigInput{}
	}

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

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

const opDeleteFleet = "DeleteFleet"

// DeleteFleetRequest is a API request type for the DeleteFleet API operation.
type DeleteFleetRequest struct {
	*aws.Request
	Input *DeleteFleetInput
	Copy  func(*DeleteFleetInput) DeleteFleetRequest
}

// Send marshals and sends the DeleteFleet API request.
func (r DeleteFleetRequest) Send() (*DeleteFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DeleteFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Deletes the specified fleet.
//
//    // Example sending a request using the DeleteFleetRequest method.
//    req := client.DeleteFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteFleet
func (c *AppStream) DeleteFleetRequest(input *DeleteFleetInput) DeleteFleetRequest {
	op := &aws.Operation{
		Name:       opDeleteFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteFleetInput{}
	}

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

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

const opDeleteImage = "DeleteImage"

// DeleteImageRequest is a API request type for the DeleteImage API operation.
type DeleteImageRequest struct {
	*aws.Request
	Input *DeleteImageInput
	Copy  func(*DeleteImageInput) DeleteImageRequest
}

// Send marshals and sends the DeleteImage API request.
func (r DeleteImageRequest) Send() (*DeleteImageOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DeleteImageRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Deletes the specified image. You cannot delete an image that is currently
// in use. After you delete an image, you cannot provision new capacity using
// the image.
//
//    // Example sending a request using the DeleteImageRequest method.
//    req := client.DeleteImageRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImage
func (c *AppStream) DeleteImageRequest(input *DeleteImageInput) DeleteImageRequest {
	op := &aws.Operation{
		Name:       opDeleteImage,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteImageInput{}
	}

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

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

const opDeleteImageBuilder = "DeleteImageBuilder"

// DeleteImageBuilderRequest is a API request type for the DeleteImageBuilder API operation.
type DeleteImageBuilderRequest struct {
	*aws.Request
	Input *DeleteImageBuilderInput
	Copy  func(*DeleteImageBuilderInput) DeleteImageBuilderRequest
}

// Send marshals and sends the DeleteImageBuilder API request.
func (r DeleteImageBuilderRequest) Send() (*DeleteImageBuilderOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DeleteImageBuilderRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Deletes the specified image builder and releases the capacity.
//
//    // Example sending a request using the DeleteImageBuilderRequest method.
//    req := client.DeleteImageBuilderRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImageBuilder
func (c *AppStream) DeleteImageBuilderRequest(input *DeleteImageBuilderInput) DeleteImageBuilderRequest {
	op := &aws.Operation{
		Name:       opDeleteImageBuilder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteImageBuilderInput{}
	}

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

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

const opDeleteStack = "DeleteStack"

// DeleteStackRequest is a API request type for the DeleteStack API operation.
type DeleteStackRequest struct {
	*aws.Request
	Input *DeleteStackInput
	Copy  func(*DeleteStackInput) DeleteStackRequest
}

// Send marshals and sends the DeleteStack API request.
func (r DeleteStackRequest) Send() (*DeleteStackOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DeleteStackRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Deletes the specified stack. After this operation completes, the environment
// can no longer be activated and any reservations made for the stack are released.
//
//    // Example sending a request using the DeleteStackRequest method.
//    req := client.DeleteStackRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteStack
func (c *AppStream) DeleteStackRequest(input *DeleteStackInput) DeleteStackRequest {
	op := &aws.Operation{
		Name:       opDeleteStack,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteStackInput{}
	}

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

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

const opDescribeDirectoryConfigs = "DescribeDirectoryConfigs"

// DescribeDirectoryConfigsRequest is a API request type for the DescribeDirectoryConfigs API operation.
type DescribeDirectoryConfigsRequest struct {
	*aws.Request
	Input *DescribeDirectoryConfigsInput
	Copy  func(*DescribeDirectoryConfigsInput) DescribeDirectoryConfigsRequest
}

// Send marshals and sends the DescribeDirectoryConfigs API request.
func (r DescribeDirectoryConfigsRequest) Send() (*DescribeDirectoryConfigsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeDirectoryConfigsRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the specified directory configurations. Note that although the
// response syntax in this topic includes the account password, this password
// is not returned in the actual response.
//
//    // Example sending a request using the DescribeDirectoryConfigsRequest method.
//    req := client.DescribeDirectoryConfigsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeDirectoryConfigs
func (c *AppStream) DescribeDirectoryConfigsRequest(input *DescribeDirectoryConfigsInput) DescribeDirectoryConfigsRequest {
	op := &aws.Operation{
		Name:       opDescribeDirectoryConfigs,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeDirectoryConfigsInput{}
	}

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

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

const opDescribeFleets = "DescribeFleets"

// DescribeFleetsRequest is a API request type for the DescribeFleets API operation.
type DescribeFleetsRequest struct {
	*aws.Request
	Input *DescribeFleetsInput
	Copy  func(*DescribeFleetsInput) DescribeFleetsRequest
}

// Send marshals and sends the DescribeFleets API request.
func (r DescribeFleetsRequest) Send() (*DescribeFleetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeFleetsRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the specified fleets or all fleets in the account.
//
//    // Example sending a request using the DescribeFleetsRequest method.
//    req := client.DescribeFleetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeFleets
func (c *AppStream) DescribeFleetsRequest(input *DescribeFleetsInput) DescribeFleetsRequest {
	op := &aws.Operation{
		Name:       opDescribeFleets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeFleetsInput{}
	}

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

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

const opDescribeImageBuilders = "DescribeImageBuilders"

// DescribeImageBuildersRequest is a API request type for the DescribeImageBuilders API operation.
type DescribeImageBuildersRequest struct {
	*aws.Request
	Input *DescribeImageBuildersInput
	Copy  func(*DescribeImageBuildersInput) DescribeImageBuildersRequest
}

// Send marshals and sends the DescribeImageBuilders API request.
func (r DescribeImageBuildersRequest) Send() (*DescribeImageBuildersOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeImageBuildersRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the specified image builders or all image builders in the account.
//
//    // Example sending a request using the DescribeImageBuildersRequest method.
//    req := client.DescribeImageBuildersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeImageBuilders
func (c *AppStream) DescribeImageBuildersRequest(input *DescribeImageBuildersInput) DescribeImageBuildersRequest {
	op := &aws.Operation{
		Name:       opDescribeImageBuilders,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeImageBuildersInput{}
	}

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

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

const opDescribeImages = "DescribeImages"

// DescribeImagesRequest is a API request type for the DescribeImages API operation.
type DescribeImagesRequest struct {
	*aws.Request
	Input *DescribeImagesInput
	Copy  func(*DescribeImagesInput) DescribeImagesRequest
}

// Send marshals and sends the DescribeImages API request.
func (r DescribeImagesRequest) Send() (*DescribeImagesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeImagesRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the specified images or all images in the account.
//
//    // Example sending a request using the DescribeImagesRequest method.
//    req := client.DescribeImagesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeImages
func (c *AppStream) DescribeImagesRequest(input *DescribeImagesInput) DescribeImagesRequest {
	op := &aws.Operation{
		Name:       opDescribeImages,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeImagesInput{}
	}

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

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

const opDescribeSessions = "DescribeSessions"

// DescribeSessionsRequest is a API request type for the DescribeSessions API operation.
type DescribeSessionsRequest struct {
	*aws.Request
	Input *DescribeSessionsInput
	Copy  func(*DescribeSessionsInput) DescribeSessionsRequest
}

// Send marshals and sends the DescribeSessions API request.
func (r DescribeSessionsRequest) Send() (*DescribeSessionsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeSessionsRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the streaming sessions for the specified stack and fleet. If a
// user ID is provided, only the streaming sessions for only that user are returned.
// If an authentication type is not provided, the default is to authenticate
// users using a streaming URL.
//
//    // Example sending a request using the DescribeSessionsRequest method.
//    req := client.DescribeSessionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeSessions
func (c *AppStream) DescribeSessionsRequest(input *DescribeSessionsInput) DescribeSessionsRequest {
	op := &aws.Operation{
		Name:       opDescribeSessions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeSessionsInput{}
	}

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

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

const opDescribeStacks = "DescribeStacks"

// DescribeStacksRequest is a API request type for the DescribeStacks API operation.
type DescribeStacksRequest struct {
	*aws.Request
	Input *DescribeStacksInput
	Copy  func(*DescribeStacksInput) DescribeStacksRequest
}

// Send marshals and sends the DescribeStacks API request.
func (r DescribeStacksRequest) Send() (*DescribeStacksOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DescribeStacksRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Describes the specified stacks or all stacks in the account.
//
//    // Example sending a request using the DescribeStacksRequest method.
//    req := client.DescribeStacksRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeStacks
func (c *AppStream) DescribeStacksRequest(input *DescribeStacksInput) DescribeStacksRequest {
	op := &aws.Operation{
		Name:       opDescribeStacks,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeStacksInput{}
	}

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

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

const opDisassociateFleet = "DisassociateFleet"

// DisassociateFleetRequest is a API request type for the DisassociateFleet API operation.
type DisassociateFleetRequest struct {
	*aws.Request
	Input *DisassociateFleetInput
	Copy  func(*DisassociateFleetInput) DisassociateFleetRequest
}

// Send marshals and sends the DisassociateFleet API request.
func (r DisassociateFleetRequest) Send() (*DisassociateFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// DisassociateFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Disassociates the specified fleet from the specified stack.
//
//    // Example sending a request using the DisassociateFleetRequest method.
//    req := client.DisassociateFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DisassociateFleet
func (c *AppStream) DisassociateFleetRequest(input *DisassociateFleetInput) DisassociateFleetRequest {
	op := &aws.Operation{
		Name:       opDisassociateFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateFleetInput{}
	}

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

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

const opExpireSession = "ExpireSession"

// ExpireSessionRequest is a API request type for the ExpireSession API operation.
type ExpireSessionRequest struct {
	*aws.Request
	Input *ExpireSessionInput
	Copy  func(*ExpireSessionInput) ExpireSessionRequest
}

// Send marshals and sends the ExpireSession API request.
func (r ExpireSessionRequest) Send() (*ExpireSessionOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// ExpireSessionRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Stops the specified streaming session.
//
//    // Example sending a request using the ExpireSessionRequest method.
//    req := client.ExpireSessionRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ExpireSession
func (c *AppStream) ExpireSessionRequest(input *ExpireSessionInput) ExpireSessionRequest {
	op := &aws.Operation{
		Name:       opExpireSession,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ExpireSessionInput{}
	}

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

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

const opListAssociatedFleets = "ListAssociatedFleets"

// ListAssociatedFleetsRequest is a API request type for the ListAssociatedFleets API operation.
type ListAssociatedFleetsRequest struct {
	*aws.Request
	Input *ListAssociatedFleetsInput
	Copy  func(*ListAssociatedFleetsInput) ListAssociatedFleetsRequest
}

// Send marshals and sends the ListAssociatedFleets API request.
func (r ListAssociatedFleetsRequest) Send() (*ListAssociatedFleetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// ListAssociatedFleetsRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Lists the fleets associated with the specified stack.
//
//    // Example sending a request using the ListAssociatedFleetsRequest method.
//    req := client.ListAssociatedFleetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListAssociatedFleets
func (c *AppStream) ListAssociatedFleetsRequest(input *ListAssociatedFleetsInput) ListAssociatedFleetsRequest {
	op := &aws.Operation{
		Name:       opListAssociatedFleets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListAssociatedFleetsInput{}
	}

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

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

const opListAssociatedStacks = "ListAssociatedStacks"

// ListAssociatedStacksRequest is a API request type for the ListAssociatedStacks API operation.
type ListAssociatedStacksRequest struct {
	*aws.Request
	Input *ListAssociatedStacksInput
	Copy  func(*ListAssociatedStacksInput) ListAssociatedStacksRequest
}

// Send marshals and sends the ListAssociatedStacks API request.
func (r ListAssociatedStacksRequest) Send() (*ListAssociatedStacksOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// ListAssociatedStacksRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Lists the stacks associated with the specified fleet.
//
//    // Example sending a request using the ListAssociatedStacksRequest method.
//    req := client.ListAssociatedStacksRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListAssociatedStacks
func (c *AppStream) ListAssociatedStacksRequest(input *ListAssociatedStacksInput) ListAssociatedStacksRequest {
	op := &aws.Operation{
		Name:       opListAssociatedStacks,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListAssociatedStacksInput{}
	}

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

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

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() (*ListTagsForResourceOutput, error) {
	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
// Amazon AppStream.
//
// Lists the tags for the specified AppStream 2.0 resource. You can tag AppStream
// 2.0 image builders, images, fleets, and stacks.
//
// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/appstream2/latest/developerguide/tagging-basic.html)
// in the Amazon AppStream 2.0 Developer Guide.
//
//    // Example sending a request using the ListTagsForResourceRequest method.
//    req := client.ListTagsForResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListTagsForResource
func (c *AppStream) 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 opStartFleet = "StartFleet"

// StartFleetRequest is a API request type for the StartFleet API operation.
type StartFleetRequest struct {
	*aws.Request
	Input *StartFleetInput
	Copy  func(*StartFleetInput) StartFleetRequest
}

// Send marshals and sends the StartFleet API request.
func (r StartFleetRequest) Send() (*StartFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// StartFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Starts the specified fleet.
//
//    // Example sending a request using the StartFleetRequest method.
//    req := client.StartFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartFleet
func (c *AppStream) StartFleetRequest(input *StartFleetInput) StartFleetRequest {
	op := &aws.Operation{
		Name:       opStartFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartFleetInput{}
	}

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

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

const opStartImageBuilder = "StartImageBuilder"

// StartImageBuilderRequest is a API request type for the StartImageBuilder API operation.
type StartImageBuilderRequest struct {
	*aws.Request
	Input *StartImageBuilderInput
	Copy  func(*StartImageBuilderInput) StartImageBuilderRequest
}

// Send marshals and sends the StartImageBuilder API request.
func (r StartImageBuilderRequest) Send() (*StartImageBuilderOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// StartImageBuilderRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Starts the specified image builder.
//
//    // Example sending a request using the StartImageBuilderRequest method.
//    req := client.StartImageBuilderRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartImageBuilder
func (c *AppStream) StartImageBuilderRequest(input *StartImageBuilderInput) StartImageBuilderRequest {
	op := &aws.Operation{
		Name:       opStartImageBuilder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartImageBuilderInput{}
	}

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

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

const opStopFleet = "StopFleet"

// StopFleetRequest is a API request type for the StopFleet API operation.
type StopFleetRequest struct {
	*aws.Request
	Input *StopFleetInput
	Copy  func(*StopFleetInput) StopFleetRequest
}

// Send marshals and sends the StopFleet API request.
func (r StopFleetRequest) Send() (*StopFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// StopFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Stops the specified fleet.
//
//    // Example sending a request using the StopFleetRequest method.
//    req := client.StopFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopFleet
func (c *AppStream) StopFleetRequest(input *StopFleetInput) StopFleetRequest {
	op := &aws.Operation{
		Name:       opStopFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopFleetInput{}
	}

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

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

const opStopImageBuilder = "StopImageBuilder"

// StopImageBuilderRequest is a API request type for the StopImageBuilder API operation.
type StopImageBuilderRequest struct {
	*aws.Request
	Input *StopImageBuilderInput
	Copy  func(*StopImageBuilderInput) StopImageBuilderRequest
}

// Send marshals and sends the StopImageBuilder API request.
func (r StopImageBuilderRequest) Send() (*StopImageBuilderOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// StopImageBuilderRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Stops the specified image builder.
//
//    // Example sending a request using the StopImageBuilderRequest method.
//    req := client.StopImageBuilderRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopImageBuilder
func (c *AppStream) StopImageBuilderRequest(input *StopImageBuilderInput) StopImageBuilderRequest {
	op := &aws.Operation{
		Name:       opStopImageBuilder,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopImageBuilderInput{}
	}

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

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

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() (*TagResourceOutput, error) {
	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
// Amazon AppStream.
//
// Adds or overwrites one or more tags for the specified AppStream 2.0 resource.
// You can tag AppStream 2.0 image builders, images, fleets, and stacks.
//
// Each tag consists of a key and an optional value. If a resource already has
// a tag with the same key, this operation updates its value.
//
// To list the current tags for your resources, use ListTagsForResource. To
// disassociate tags from your resources, use UntagResource.
//
// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/appstream2/latest/developerguide/tagging-basic.html)
// in the Amazon AppStream 2.0 Developer Guide.
//
//    // Example sending a request using the TagResourceRequest method.
//    req := client.TagResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/TagResource
func (c *AppStream) 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)
	output.responseMetadata = aws.Response{Request: req}

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

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() (*UntagResourceOutput, error) {
	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
// Amazon AppStream.
//
// Disassociates the specified tags from the specified AppStream 2.0 resource.
//
// To list the current tags for your resources, use ListTagsForResource.
//
// For more information about tags, see Tagging Your Resources (http://docs.aws.amazon.com/appstream2/latest/developerguide/tagging-basic.html)
// in the Amazon AppStream 2.0 Developer Guide.
//
//    // Example sending a request using the UntagResourceRequest method.
//    req := client.UntagResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UntagResource
func (c *AppStream) 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)
	output.responseMetadata = aws.Response{Request: req}

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

const opUpdateDirectoryConfig = "UpdateDirectoryConfig"

// UpdateDirectoryConfigRequest is a API request type for the UpdateDirectoryConfig API operation.
type UpdateDirectoryConfigRequest struct {
	*aws.Request
	Input *UpdateDirectoryConfigInput
	Copy  func(*UpdateDirectoryConfigInput) UpdateDirectoryConfigRequest
}

// Send marshals and sends the UpdateDirectoryConfig API request.
func (r UpdateDirectoryConfigRequest) Send() (*UpdateDirectoryConfigOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// UpdateDirectoryConfigRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Updates the specified directory configuration.
//
//    // Example sending a request using the UpdateDirectoryConfigRequest method.
//    req := client.UpdateDirectoryConfigRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateDirectoryConfig
func (c *AppStream) UpdateDirectoryConfigRequest(input *UpdateDirectoryConfigInput) UpdateDirectoryConfigRequest {
	op := &aws.Operation{
		Name:       opUpdateDirectoryConfig,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateDirectoryConfigInput{}
	}

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

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

const opUpdateFleet = "UpdateFleet"

// UpdateFleetRequest is a API request type for the UpdateFleet API operation.
type UpdateFleetRequest struct {
	*aws.Request
	Input *UpdateFleetInput
	Copy  func(*UpdateFleetInput) UpdateFleetRequest
}

// Send marshals and sends the UpdateFleet API request.
func (r UpdateFleetRequest) Send() (*UpdateFleetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// UpdateFleetRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Updates the specified fleet.
//
// If the fleet is in the STOPPED state, you can update any attribute except
// the fleet name. If the fleet is in the RUNNING state, you can update the
// DisplayName and ComputeCapacity attributes. If the fleet is in the STARTING
// or STOPPING state, you can't update it.
//
//    // Example sending a request using the UpdateFleetRequest method.
//    req := client.UpdateFleetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateFleet
func (c *AppStream) UpdateFleetRequest(input *UpdateFleetInput) UpdateFleetRequest {
	op := &aws.Operation{
		Name:       opUpdateFleet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateFleetInput{}
	}

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

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

const opUpdateStack = "UpdateStack"

// UpdateStackRequest is a API request type for the UpdateStack API operation.
type UpdateStackRequest struct {
	*aws.Request
	Input *UpdateStackInput
	Copy  func(*UpdateStackInput) UpdateStackRequest
}

// Send marshals and sends the UpdateStack API request.
func (r UpdateStackRequest) Send() (*UpdateStackOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

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

// UpdateStackRequest returns a request value for making API operation for
// Amazon AppStream.
//
// Updates the specified stack.
//
//    // Example sending a request using the UpdateStackRequest method.
//    req := client.UpdateStackRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateStack
func (c *AppStream) UpdateStackRequest(input *UpdateStackInput) UpdateStackRequest {
	op := &aws.Operation{
		Name:       opUpdateStack,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateStackInput{}
	}

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

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

// Describes an application in the application catalog.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/Application
type Application struct {
	_ struct{} `type:"structure"`

	// The application name for display.
	DisplayName *string `min:"1" type:"string"`

	// If there is a problem, the application can be disabled after image creation.
	Enabled *bool `type:"boolean"`

	// The URL for the application icon. This URL might be time-limited.
	IconURL *string `min:"1" type:"string"`

	// The arguments that are passed to the application at launch.
	LaunchParameters *string `min:"1" type:"string"`

	// The path to the application executable in the instance.
	LaunchPath *string `min:"1" type:"string"`

	// Additional attributes that describe the application.
	Metadata map[string]string `type:"map"`

	// The name of the application.
	Name *string `min:"1" type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/AssociateFleetRequest
type AssociateFleetInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The name of the stack.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/AssociateFleetResult
type AssociateFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Describes the capacity for a fleet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ComputeCapacity
type ComputeCapacity struct {
	_ struct{} `type:"structure"`

	// The desired number of streaming instances.
	//
	// DesiredInstances is a required field
	DesiredInstances *int64 `type:"integer" required:"true"`
}

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

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

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

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

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

// Describes the capacity status for a fleet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ComputeCapacityStatus
type ComputeCapacityStatus struct {
	_ struct{} `type:"structure"`

	// The number of currently available instances that can be used to stream sessions.
	Available *int64 `type:"integer"`

	// The desired number of streaming instances.
	//
	// Desired is a required field
	Desired *int64 `type:"integer" required:"true"`

	// The number of instances in use for streaming.
	InUse *int64 `type:"integer"`

	// The total number of simultaneous streaming instances that are running.
	Running *int64 `type:"integer"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CopyImageRequest
type CopyImageInput struct {
	_ struct{} `type:"structure"`

	// The description that the image will have when it is copied to the destination.
	DestinationImageDescription *string `type:"string"`

	// The name that the image will have when it is copied to the destination.
	//
	// DestinationImageName is a required field
	DestinationImageName *string `type:"string" required:"true"`

	// The destination region to which the image will be copied. This parameter
	// is required, even if you are copying an image within the same region.
	//
	// DestinationRegion is a required field
	DestinationRegion *string `min:"1" type:"string" required:"true"`

	// The name of the image to copy.
	//
	// SourceImageName is a required field
	SourceImageName *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CopyImageResponse
type CopyImageOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The name of the destination image.
	DestinationImageName *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateDirectoryConfigRequest
type CreateDirectoryConfigInput struct {
	_ struct{} `type:"structure"`

	// The fully qualified name of the directory (for example, corp.example.com).
	//
	// DirectoryName is a required field
	DirectoryName *string `type:"string" required:"true"`

	// The distinguished names of the organizational units for computer accounts.
	//
	// OrganizationalUnitDistinguishedNames is a required field
	OrganizationalUnitDistinguishedNames []string `type:"list" required:"true"`

	// The credentials for the service account used by the streaming instance to
	// connect to the directory.
	//
	// ServiceAccountCredentials is a required field
	ServiceAccountCredentials *ServiceAccountCredentials `type:"structure" required:"true"`
}

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

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

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

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

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

	if s.ServiceAccountCredentials == nil {
		invalidParams.Add(aws.NewErrParamRequired("ServiceAccountCredentials"))
	}
	if s.ServiceAccountCredentials != nil {
		if err := s.ServiceAccountCredentials.Validate(); err != nil {
			invalidParams.AddNested("ServiceAccountCredentials", err.(aws.ErrInvalidParams))
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateDirectoryConfigResult
type CreateDirectoryConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the directory configuration.
	DirectoryConfig *DirectoryConfig `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateFleetRequest
type CreateFleetInput struct {
	_ struct{} `type:"structure"`

	// The desired capacity for the fleet.
	//
	// ComputeCapacity is a required field
	ComputeCapacity *ComputeCapacity `type:"structure" required:"true"`

	// The description for display.
	Description *string `type:"string"`

	// The time after disconnection when a session is considered to have ended,
	// in seconds. If a user who was disconnected reconnects within this time interval,
	// the user is connected to their previous session. Specify a value between
	// 60 and 57600.
	DisconnectTimeoutInSeconds *int64 `type:"integer"`

	// The fleet name for display.
	DisplayName *string `type:"string"`

	// The information needed to join a Microsoft Active Directory domain.
	DomainJoinInfo *DomainJoinInfo `type:"structure"`

	// Enables or disables default internet access for the fleet.
	EnableDefaultInternetAccess *bool `type:"boolean"`

	// The fleet type.
	//
	// ALWAYS_ONProvides users with instant-on access to their apps. You are charged
	// for all running instances in your fleet, even if no users are streaming apps.
	//
	// ON_DEMANDProvide users with access to applications after they connect, which
	// takes one to two minutes. You are charged for instance streaming when users
	// are connected and a small hourly fee for instances that are not streaming
	// apps.
	FleetType FleetType `type:"string" enum:"true"`

	// The name of the image used to create the fleet.
	//
	// ImageName is a required field
	ImageName *string `min:"1" type:"string" required:"true"`

	// The instance type to use when launching fleet instances. The following instance
	// types are available:
	//
	//    * stream.standard.medium
	//
	//    * stream.standard.large
	//
	//    * stream.compute.large
	//
	//    * stream.compute.xlarge
	//
	//    * stream.compute.2xlarge
	//
	//    * stream.compute.4xlarge
	//
	//    * stream.compute.8xlarge
	//
	//    * stream.memory.large
	//
	//    * stream.memory.xlarge
	//
	//    * stream.memory.2xlarge
	//
	//    * stream.memory.4xlarge
	//
	//    * stream.memory.8xlarge
	//
	//    * stream.graphics-design.large
	//
	//    * stream.graphics-design.xlarge
	//
	//    * stream.graphics-design.2xlarge
	//
	//    * stream.graphics-design.4xlarge
	//
	//    * stream.graphics-desktop.2xlarge
	//
	//    * stream.graphics-pro.4xlarge
	//
	//    * stream.graphics-pro.8xlarge
	//
	//    * stream.graphics-pro.16xlarge
	//
	// InstanceType is a required field
	InstanceType *string `min:"1" type:"string" required:"true"`

	// The maximum time that a streaming session can run, in seconds. Specify a
	// value between 600 and 57600.
	MaxUserDurationInSeconds *int64 `type:"integer"`

	// A unique name for the fleet.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`

	// The VPC configuration for the fleet.
	VpcConfig *VpcConfig `type:"structure"`
}

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

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

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

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

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

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

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.ComputeCapacity != nil {
		if err := s.ComputeCapacity.Validate(); err != nil {
			invalidParams.AddNested("ComputeCapacity", err.(aws.ErrInvalidParams))
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateFleetResult
type CreateFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the fleet.
	Fleet *Fleet `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilderRequest
type CreateImageBuilderInput struct {
	_ struct{} `type:"structure"`

	// The version of the AppStream 2.0 agent to use for this image builder. To
	// use the latest version of the AppStream 2.0 agent, specify [LATEST].
	AppstreamAgentVersion *string `min:"1" type:"string"`

	// The description for display.
	Description *string `type:"string"`

	// The image builder name for display.
	DisplayName *string `type:"string"`

	// The information needed to join a Microsoft Active Directory domain.
	DomainJoinInfo *DomainJoinInfo `type:"structure"`

	// Enables or disables default internet access for the image builder.
	EnableDefaultInternetAccess *bool `type:"boolean"`

	// The name of the image used to create the builder.
	//
	// ImageName is a required field
	ImageName *string `min:"1" type:"string" required:"true"`

	// The instance type to use when launching the image builder.
	//
	// InstanceType is a required field
	InstanceType *string `min:"1" type:"string" required:"true"`

	// A unique name for the image builder.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`

	// The VPC configuration for the image builder. You can specify only one subnet.
	VpcConfig *VpcConfig `type:"structure"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilderResult
type CreateImageBuilderOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image builder.
	ImageBuilder *ImageBuilder `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilderStreamingURLRequest
type CreateImageBuilderStreamingURLInput struct {
	_ struct{} `type:"structure"`

	// The name of the image builder.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The time that the streaming URL will be valid, in seconds. Specify a value
	// between 1 and 604800 seconds. The default is 3600 seconds.
	Validity *int64 `type:"long"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateImageBuilderStreamingURLResult
type CreateImageBuilderStreamingURLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The elapsed time, in seconds after the Unix epoch, when this URL expires.
	Expires *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The URL to start the AppStream 2.0 streaming session.
	StreamingURL *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStackRequest
type CreateStackInput struct {
	_ struct{} `type:"structure"`

	// The description for display.
	Description *string `type:"string"`

	// The stack name for display.
	DisplayName *string `type:"string"`

	// The URL that users are redirected to after they click the Send Feedback link.
	// If no URL is specified, no Send Feedback link is displayed.
	FeedbackURL *string `type:"string"`

	// The name of the stack.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The URL that users are redirected to after their streaming session ends.
	RedirectURL *string `type:"string"`

	// The storage connectors to enable.
	StorageConnectors []StorageConnector `type:"list"`

	// The actions that are enabled or disabled for users during their streaming
	// sessions. By default, these actions are enabled.
	UserSettings []UserSetting `min:"1" type:"list"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStackResult
type CreateStackOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the stack.
	Stack *Stack `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStreamingURLRequest
type CreateStreamingURLInput struct {
	_ struct{} `type:"structure"`

	// The name of the application to launch after the session starts. This is the
	// name that you specified as Name in the Image Assistant.
	ApplicationId *string `min:"1" type:"string"`

	// The name of the fleet.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The session context. For more information, see Session Context (http://docs.aws.amazon.com/appstream2/latest/developerguide/managing-stacks-fleets.html#managing-stacks-fleets-parameters)
	// in the Amazon AppStream 2.0 Developer Guide.
	SessionContext *string `min:"1" type:"string"`

	// The name of the stack.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`

	// The ID of the user.
	//
	// UserId is a required field
	UserId *string `min:"2" type:"string" required:"true"`

	// The time that the streaming URL will be valid, in seconds. Specify a value
	// between 1 and 604800 seconds. The default is 60 seconds.
	Validity *int64 `type:"long"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/CreateStreamingURLResult
type CreateStreamingURLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The elapsed time, in seconds after the Unix epoch, when this URL expires.
	Expires *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The URL to start the AppStream 2.0 streaming session.
	StreamingURL *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteDirectoryConfigRequest
type DeleteDirectoryConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the directory configuration.
	//
	// DirectoryName is a required field
	DirectoryName *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteDirectoryConfigResult
type DeleteDirectoryConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteFleetRequest
type DeleteFleetInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteFleetResult
type DeleteFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImageBuilderRequest
type DeleteImageBuilderInput struct {
	_ struct{} `type:"structure"`

	// The name of the image builder.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImageBuilderResult
type DeleteImageBuilderOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image builder.
	ImageBuilder *ImageBuilder `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImageRequest
type DeleteImageInput struct {
	_ struct{} `type:"structure"`

	// The name of the image.
	//
	// Name is a required field
	Name *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteImageResult
type DeleteImageOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image.
	Image *Image `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteStackRequest
type DeleteStackInput struct {
	_ struct{} `type:"structure"`

	// The name of the stack.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DeleteStackResult
type DeleteStackOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeDirectoryConfigsRequest
type DescribeDirectoryConfigsInput struct {
	_ struct{} `type:"structure"`

	// The directory names.
	DirectoryNames []string `type:"list"`

	// The maximum size of each page of results.
	MaxResults *int64 `type:"integer"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeDirectoryConfigsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeDirectoryConfigsInput"}
	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/appstream-2016-12-01/DescribeDirectoryConfigsResult
type DescribeDirectoryConfigsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the directory configurations. Note that although the response
	// syntax in this topic includes the account password, this password is not
	// returned in the actual response.
	DirectoryConfigs []DirectoryConfig `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeFleetsRequest
type DescribeFleetsInput struct {
	_ struct{} `type:"structure"`

	// The names of the fleets to describe.
	Names []string `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeFleetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeFleetsInput"}
	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/appstream-2016-12-01/DescribeFleetsResult
type DescribeFleetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the fleets.
	Fleets []Fleet `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeImageBuildersRequest
type DescribeImageBuildersInput struct {
	_ struct{} `type:"structure"`

	// The maximum size of each page of results.
	MaxResults *int64 `type:"integer"`

	// The names of the image builders to describe.
	Names []string `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeImageBuildersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeImageBuildersInput"}
	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/appstream-2016-12-01/DescribeImageBuildersResult
type DescribeImageBuildersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image builders.
	ImageBuilders []ImageBuilder `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeImagesRequest
type DescribeImagesInput struct {
	_ struct{} `type:"structure"`

	// The names of the images to describe.
	Names []string `type:"list"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeImagesResult
type DescribeImagesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the images.
	Images []Image `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeSessionsRequest
type DescribeSessionsInput struct {
	_ struct{} `type:"structure"`

	// The authentication method. Specify API for a user authenticated using a streaming
	// URL or SAML for a SAML federated user. The default is to authenticate users
	// using a streaming URL.
	AuthenticationType AuthenticationType `type:"string" enum:"true"`

	// The name of the fleet. This value is case-sensitive.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The size of each page of results. The default value is 20 and the maximum
	// value is 50.
	Limit *int64 `type:"integer"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`

	// The name of the stack. This value is case-sensitive.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`

	// The user ID.
	UserId *string `min:"2" type:"string"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeSessionsResult
type DescribeSessionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`

	// Information about the streaming sessions.
	Sessions []Session `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DescribeStacksRequest
type DescribeStacksInput struct {
	_ struct{} `type:"structure"`

	// The names of the stacks to describe.
	Names []string `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeStacksInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeStacksInput"}
	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/appstream-2016-12-01/DescribeStacksResult
type DescribeStacksOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`

	// Information about the stacks.
	Stacks []Stack `type:"list"`
}

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

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

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

// Configuration information for the directory used to join domains.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DirectoryConfig
type DirectoryConfig struct {
	_ struct{} `type:"structure"`

	// The time the directory configuration was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The fully qualified name of the directory (for example, corp.example.com).
	//
	// DirectoryName is a required field
	DirectoryName *string `type:"string" required:"true"`

	// The distinguished names of the organizational units for computer accounts.
	OrganizationalUnitDistinguishedNames []string `type:"list"`

	// The credentials for the service account used by the streaming instance to
	// connect to the directory.
	ServiceAccountCredentials *ServiceAccountCredentials `type:"structure"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DisassociateFleetRequest
type DisassociateFleetInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The name of the stack.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DisassociateFleetResult
type DisassociateFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Contains the information needed to join a Microsoft Active Directory domain.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/DomainJoinInfo
type DomainJoinInfo struct {
	_ struct{} `type:"structure"`

	// The fully qualified name of the directory (for example, corp.example.com).
	DirectoryName *string `type:"string"`

	// The distinguished name of the organizational unit for computer accounts.
	OrganizationalUnitDistinguishedName *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ExpireSessionRequest
type ExpireSessionInput struct {
	_ struct{} `type:"structure"`

	// The ID of the streaming session.
	//
	// SessionId is a required field
	SessionId *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ExpireSessionResult
type ExpireSessionOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Contains the parameters for a fleet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/Fleet
type Fleet struct {
	_ struct{} `type:"structure"`

	// The ARN for the fleet.
	//
	// Arn is a required field
	Arn *string `type:"string" required:"true"`

	// The capacity status for the fleet.
	//
	// ComputeCapacityStatus is a required field
	ComputeCapacityStatus *ComputeCapacityStatus `type:"structure" required:"true"`

	// The time the fleet was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The description for display.
	Description *string `min:"1" type:"string"`

	// The time after disconnection when a session is considered to have ended,
	// in seconds. If a user who was disconnected reconnects within this time interval,
	// the user is connected to their previous session. Specify a value between
	// 60 and 57600.
	DisconnectTimeoutInSeconds *int64 `type:"integer"`

	// The fleet name for display.
	DisplayName *string `min:"1" type:"string"`

	// The information needed to join a Microsoft Active Directory domain.
	DomainJoinInfo *DomainJoinInfo `type:"structure"`

	// Indicates whether default internet access is enabled for the fleet.
	EnableDefaultInternetAccess *bool `type:"boolean"`

	// The fleet errors.
	FleetErrors []FleetError `type:"list"`

	// The fleet type.
	//
	// ALWAYS_ONProvides users with instant-on access to their apps. You are charged
	// for all running instances in your fleet, even if no users are streaming apps.
	//
	// ON_DEMANDProvide users with access to applications after they connect, which
	// takes one to two minutes. You are charged for instance streaming when users
	// are connected and a small hourly fee for instances that are not streaming
	// apps.
	FleetType FleetType `type:"string" enum:"true"`

	// The name of the image used to create the fleet.
	//
	// ImageName is a required field
	ImageName *string `min:"1" type:"string" required:"true"`

	// The instance type to use when launching fleet instances.
	//
	// InstanceType is a required field
	InstanceType *string `min:"1" type:"string" required:"true"`

	// The maximum time that a streaming session can run, in seconds. Specify a
	// value between 600 and 57600.
	MaxUserDurationInSeconds *int64 `type:"integer"`

	// The name of the fleet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The current state for the fleet.
	//
	// State is a required field
	State FleetState `type:"string" required:"true" enum:"true"`

	// The VPC configuration for the fleet.
	VpcConfig *VpcConfig `type:"structure"`
}

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

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

// Describes a fleet error.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/FleetError
type FleetError struct {
	_ struct{} `type:"structure"`

	// The error code.
	ErrorCode FleetErrorCode `type:"string" enum:"true"`

	// The error message.
	ErrorMessage *string `min:"1" type:"string"`
}

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

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

// Describes an image.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/Image
type Image struct {
	_ struct{} `type:"structure"`

	// The applications associated with the image.
	Applications []Application `type:"list"`

	// The version of the AppStream 2.0 agent to use for instances that are launched
	// from this image.
	AppstreamAgentVersion *string `min:"1" type:"string"`

	// The ARN of the image.
	Arn *string `type:"string"`

	// The ARN of the image from which this image was created.
	BaseImageArn *string `type:"string"`

	// The time the image was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The description for display.
	Description *string `min:"1" type:"string"`

	// The image name for display.
	DisplayName *string `min:"1" type:"string"`

	// Indicates whether an image builder can be launched from this image.
	ImageBuilderSupported *bool `type:"boolean"`

	// The name of the image.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The operating system platform of the image.
	Platform PlatformType `type:"string" enum:"true"`

	// The release date of the public base image. For private images, this date
	// is the release date of the base image from which the image was created.
	PublicBaseImageReleasedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The image starts in the PENDING state. If image creation succeeds, the state
	// is AVAILABLE. If image creation fails, the state is FAILED.
	State ImageState `type:"string" enum:"true"`

	// The reason why the last state change occurred.
	StateChangeReason *ImageStateChangeReason `type:"structure"`

	// Indicates whether the image is public or private.
	Visibility VisibilityType `type:"string" enum:"true"`
}

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

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

// Describes a streaming instance used for editing an image. New images are
// created from a snapshot through an image builder.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ImageBuilder
type ImageBuilder struct {
	_ struct{} `type:"structure"`

	// The version of the AppStream 2.0 agent that is currently being used by this
	// image builder.
	AppstreamAgentVersion *string `min:"1" type:"string"`

	// The ARN for the image builder.
	Arn *string `type:"string"`

	// The time stamp when the image builder was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The description for display.
	Description *string `min:"1" type:"string"`

	// The image builder name for display.
	DisplayName *string `min:"1" type:"string"`

	// The information needed to join a Microsoft Active Directory domain.
	DomainJoinInfo *DomainJoinInfo `type:"structure"`

	// Enables or disables default internet access for the image builder.
	EnableDefaultInternetAccess *bool `type:"boolean"`

	// The ARN of the image from which this builder was created.
	ImageArn *string `type:"string"`

	// The image builder errors.
	ImageBuilderErrors []ResourceError `type:"list"`

	// The instance type for the image builder.
	InstanceType *string `min:"1" type:"string"`

	// The name of the image builder.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The operating system platform of the image builder.
	Platform PlatformType `type:"string" enum:"true"`

	// The state of the image builder.
	State ImageBuilderState `type:"string" enum:"true"`

	// The reason why the last state change occurred.
	StateChangeReason *ImageBuilderStateChangeReason `type:"structure"`

	// The VPC configuration of the image builder.
	VpcConfig *VpcConfig `type:"structure"`
}

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

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

// Describes the reason why the last image builder state change occurred.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ImageBuilderStateChangeReason
type ImageBuilderStateChangeReason struct {
	_ struct{} `type:"structure"`

	// The state change reason code.
	Code ImageBuilderStateChangeReasonCode `type:"string" enum:"true"`

	// The state change reason message.
	Message *string `min:"1" type:"string"`
}

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

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

// Describes the reason why the last image state change occurred.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ImageStateChangeReason
type ImageStateChangeReason struct {
	_ struct{} `type:"structure"`

	// The state change reason code.
	Code ImageStateChangeReasonCode `type:"string" enum:"true"`

	// The state change reason message.
	Message *string `min:"1" type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListAssociatedFleetsRequest
type ListAssociatedFleetsInput struct {
	_ struct{} `type:"structure"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`

	// The name of the stack.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListAssociatedFleetsResult
type ListAssociatedFleetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The names of the fleets.
	Names []string `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListAssociatedStacksRequest
type ListAssociatedStacksInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If this value is null, it retrieves the first page.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

	if s.FleetName == nil {
		invalidParams.Add(aws.NewErrParamRequired("FleetName"))
	}
	if s.FleetName != nil && len(*s.FleetName) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("FleetName", 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/appstream-2016-12-01/ListAssociatedStacksResult
type ListAssociatedStacksOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The names of the stacks.
	Names []string `type:"list"`

	// The pagination token to use to retrieve the next page of results for this
	// operation. If there are no more pages, this value is null.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListTagsForResourceRequest
type ListTagsForResourceInput struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the resource.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`
}

// 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.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ListTagsForResourceResponse
type ListTagsForResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The information about the tags.
	Tags map[string]string `min:"1" type:"map"`
}

// 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
}

// Describes a resource error.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ResourceError
type ResourceError struct {
	_ struct{} `type:"structure"`

	// The error code.
	ErrorCode FleetErrorCode `type:"string" enum:"true"`

	// The error message.
	ErrorMessage *string `min:"1" type:"string"`

	// The time the error occurred.
	ErrorTimestamp *time.Time `type:"timestamp" timestampFormat:"unix"`
}

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

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

// Describes the credentials for the service account used by the streaming instance
// to connect to the directory.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/ServiceAccountCredentials
type ServiceAccountCredentials struct {
	_ struct{} `type:"structure"`

	// The user name of the account. This account must have the following privileges:
	// create computer objects, join computers to the domain, and change/reset the
	// password on descendant computer objects for the organizational units specified.
	//
	// AccountName is a required field
	AccountName *string `min:"1" type:"string" required:"true"`

	// The password for the account.
	//
	// AccountPassword is a required field
	AccountPassword *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

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

// Describes a streaming session.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/Session
type Session struct {
	_ struct{} `type:"structure"`

	// The authentication method. The user is authenticated using a streaming URL
	// (API) or SAML federation (SAML).
	AuthenticationType AuthenticationType `type:"string" enum:"true"`

	// The name of the fleet for the streaming session.
	//
	// FleetName is a required field
	FleetName *string `min:"1" type:"string" required:"true"`

	// The ID of the streaming session.
	//
	// Id is a required field
	Id *string `min:"1" type:"string" required:"true"`

	// The name of the stack for the streaming session.
	//
	// StackName is a required field
	StackName *string `min:"1" type:"string" required:"true"`

	// The current state of the streaming session.
	//
	// State is a required field
	State SessionState `type:"string" required:"true" enum:"true"`

	// The identifier of the user for whom the session was created.
	//
	// UserId is a required field
	UserId *string `min:"2" type:"string" required:"true"`
}

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

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

// Describes a stack.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/Stack
type Stack struct {
	_ struct{} `type:"structure"`

	// The ARN of the stack.
	Arn *string `type:"string"`

	// The time the stack was created.
	CreatedTime *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The description for display.
	Description *string `min:"1" type:"string"`

	// The stack name for display.
	DisplayName *string `min:"1" type:"string"`

	// The URL that users are redirected to after they click the Send Feedback link.
	// If no URL is specified, no Send Feedback link is displayed.
	FeedbackURL *string `type:"string"`

	// The name of the stack.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The URL that users are redirected to after their streaming session ends.
	RedirectURL *string `type:"string"`

	// The errors for the stack.
	StackErrors []StackError `type:"list"`

	// The storage connectors to enable.
	StorageConnectors []StorageConnector `type:"list"`

	// The actions that are enabled or disabled for users during their streaming
	// sessions. By default these actions are enabled.
	UserSettings []UserSetting `min:"1" type:"list"`
}

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

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

// Describes a stack error.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StackError
type StackError struct {
	_ struct{} `type:"structure"`

	// The error code.
	ErrorCode StackErrorCode `type:"string" enum:"true"`

	// The error message.
	ErrorMessage *string `min:"1" type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartFleetRequest
type StartFleetInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartFleetResult
type StartFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartImageBuilderRequest
type StartImageBuilderInput struct {
	_ struct{} `type:"structure"`

	// The version of the AppStream 2.0 agent to use for this image builder. To
	// use the latest version of the AppStream 2.0 agent, specify [LATEST].
	AppstreamAgentVersion *string `min:"1" type:"string"`

	// The name of the image builder.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StartImageBuilderResult
type StartImageBuilderOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image builder.
	ImageBuilder *ImageBuilder `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopFleetRequest
type StopFleetInput struct {
	_ struct{} `type:"structure"`

	// The name of the fleet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopFleetResult
type StopFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopImageBuilderRequest
type StopImageBuilderInput struct {
	_ struct{} `type:"structure"`

	// The name of the image builder.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StopImageBuilderResult
type StopImageBuilderOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the image builder.
	ImageBuilder *ImageBuilder `type:"structure"`
}

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

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

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

// Describes a storage connector.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/StorageConnector
type StorageConnector struct {
	_ struct{} `type:"structure"`

	// The type of storage connector.
	//
	// ConnectorType is a required field
	ConnectorType StorageConnectorType `type:"string" required:"true" enum:"true"`

	// The ARN of the storage connector.
	ResourceIdentifier *string `min:"1" type:"string"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/TagResourceRequest
type TagResourceInput struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the resource.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// The tags to associate. A tag is a key-value pair (the value is optional).
	// For example, Environment=Test, or, if you do not specify a value, Environment=.
	//
	// If you do not specify a value, we set the value to an empty string.
	//
	// Tags is a required field
	Tags map[string]string `min:"1" type:"map" 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.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/TagResourceResponse
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/appstream-2016-12-01/UntagResourceRequest
type UntagResourceInput struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of the resource.
	//
	// ResourceArn is a required field
	ResourceArn *string `type:"string" required:"true"`

	// The tag keys for the tags to disassociate.
	//
	// 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.ResourceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("ResourceArn"))
	}

	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/appstream-2016-12-01/UntagResourceResponse
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/appstream-2016-12-01/UpdateDirectoryConfigRequest
type UpdateDirectoryConfigInput struct {
	_ struct{} `type:"structure"`

	// The name of the directory configuration.
	//
	// DirectoryName is a required field
	DirectoryName *string `type:"string" required:"true"`

	// The distinguished names of the organizational units for computer accounts.
	OrganizationalUnitDistinguishedNames []string `type:"list"`

	// The credentials for the service account used by the streaming instance to
	// connect to the directory.
	ServiceAccountCredentials *ServiceAccountCredentials `type:"structure"`
}

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

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

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

	if s.DirectoryName == nil {
		invalidParams.Add(aws.NewErrParamRequired("DirectoryName"))
	}
	if s.ServiceAccountCredentials != nil {
		if err := s.ServiceAccountCredentials.Validate(); err != nil {
			invalidParams.AddNested("ServiceAccountCredentials", err.(aws.ErrInvalidParams))
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateDirectoryConfigResult
type UpdateDirectoryConfigOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the directory configuration.
	DirectoryConfig *DirectoryConfig `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateFleetRequest
type UpdateFleetInput struct {
	_ struct{} `type:"structure"`

	// The fleet attributes to delete.
	AttributesToDelete []FleetAttribute `type:"list"`

	// The desired capacity for the fleet.
	ComputeCapacity *ComputeCapacity `type:"structure"`

	// Deletes the VPC association for the specified fleet.
	DeleteVpcConfig *bool `deprecated:"true" type:"boolean"`

	// The description for display.
	Description *string `type:"string"`

	// The time after disconnection when a session is considered to have ended,
	// in seconds. If a user who was disconnected reconnects within this time interval,
	// the user is connected to their previous session. Specify a value between
	// 60 and 57600.
	DisconnectTimeoutInSeconds *int64 `type:"integer"`

	// The fleet name for display.
	DisplayName *string `type:"string"`

	// The information needed to join a Microsoft Active Directory domain.
	DomainJoinInfo *DomainJoinInfo `type:"structure"`

	// Enables or disables default internet access for the fleet.
	EnableDefaultInternetAccess *bool `type:"boolean"`

	// The name of the image used to create the fleet.
	ImageName *string `min:"1" type:"string"`

	// The instance type to use when launching fleet instances. The following instance
	// types are available:
	//
	//    * stream.standard.medium
	//
	//    * stream.standard.large
	//
	//    * stream.compute.large
	//
	//    * stream.compute.xlarge
	//
	//    * stream.compute.2xlarge
	//
	//    * stream.compute.4xlarge
	//
	//    * stream.compute.8xlarge
	//
	//    * stream.memory.large
	//
	//    * stream.memory.xlarge
	//
	//    * stream.memory.2xlarge
	//
	//    * stream.memory.4xlarge
	//
	//    * stream.memory.8xlarge
	//
	//    * stream.graphics-design.large
	//
	//    * stream.graphics-design.xlarge
	//
	//    * stream.graphics-design.2xlarge
	//
	//    * stream.graphics-design.4xlarge
	//
	//    * stream.graphics-desktop.2xlarge
	//
	//    * stream.graphics-pro.4xlarge
	//
	//    * stream.graphics-pro.8xlarge
	//
	//    * stream.graphics-pro.16xlarge
	InstanceType *string `min:"1" type:"string"`

	// The maximum time that a streaming session can run, in seconds. Specify a
	// value between 600 and 57600.
	MaxUserDurationInSeconds *int64 `type:"integer"`

	// A unique name for the fleet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The VPC configuration for the fleet.
	VpcConfig *VpcConfig `type:"structure"`
}

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

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

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

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}
	if s.ComputeCapacity != nil {
		if err := s.ComputeCapacity.Validate(); err != nil {
			invalidParams.AddNested("ComputeCapacity", err.(aws.ErrInvalidParams))
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateFleetResult
type UpdateFleetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the fleet.
	Fleet *Fleet `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateStackRequest
type UpdateStackInput struct {
	_ struct{} `type:"structure"`

	// The stack attributes to delete.
	AttributesToDelete []StackAttribute `type:"list"`

	// Deletes the storage connectors currently enabled for the stack.
	DeleteStorageConnectors *bool `deprecated:"true" type:"boolean"`

	// The description for display.
	Description *string `type:"string"`

	// The stack name for display.
	DisplayName *string `type:"string"`

	// The URL that users are redirected to after they click the Send Feedback link.
	// If no URL is specified, no Send Feedback link is displayed.
	FeedbackURL *string `type:"string"`

	// The name of the stack.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The URL that users are redirected to after their streaming session ends.
	RedirectURL *string `type:"string"`

	// The storage connectors to enable.
	StorageConnectors []StorageConnector `type:"list"`

	// The actions that are enabled or disabled for users during their streaming
	// sessions. By default, these actions are enabled.
	UserSettings []UserSetting `min:"1" type:"list"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UpdateStackResult
type UpdateStackOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the stack.
	Stack *Stack `type:"structure"`
}

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

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

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

// Describes an action and whether the action is enabled or disabled for users
// during their streaming sessions.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/UserSetting
type UserSetting struct {
	_ struct{} `type:"structure"`

	// The action that is enabled or disabled.
	//
	// Action is a required field
	Action Action `type:"string" required:"true" enum:"true"`

	// Indicates whether the action is enabled or disabled.
	//
	// Permission is a required field
	Permission Permission `type:"string" required:"true" enum:"true"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *UserSetting) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UserSetting"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}
	if len(s.Permission) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Permission"))
	}

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

// Describes VPC configuration information.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/appstream-2016-12-01/VpcConfig
type VpcConfig struct {
	_ struct{} `type:"structure"`

	// The security groups for the fleet.
	SecurityGroupIds []string `type:"list"`

	// The subnets to which a network interface is established from the fleet instance.
	SubnetIds []string `type:"list"`
}

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

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

type Action string

// Enum values for Action
const (
	ActionClipboardCopyFromLocalDevice Action = "CLIPBOARD_COPY_FROM_LOCAL_DEVICE"
	ActionClipboardCopyToLocalDevice   Action = "CLIPBOARD_COPY_TO_LOCAL_DEVICE"
	ActionFileUpload                   Action = "FILE_UPLOAD"
	ActionFileDownload                 Action = "FILE_DOWNLOAD"
	ActionPrintingToLocalDevice        Action = "PRINTING_TO_LOCAL_DEVICE"
)

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

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

type AuthenticationType string

// Enum values for AuthenticationType
const (
	AuthenticationTypeApi      AuthenticationType = "API"
	AuthenticationTypeSaml     AuthenticationType = "SAML"
	AuthenticationTypeUserpool AuthenticationType = "USERPOOL"
)

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

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

// The fleet attribute.
type FleetAttribute string

// Enum values for FleetAttribute
const (
	FleetAttributeVpcConfiguration                 FleetAttribute = "VPC_CONFIGURATION"
	FleetAttributeVpcConfigurationSecurityGroupIds FleetAttribute = "VPC_CONFIGURATION_SECURITY_GROUP_IDS"
	FleetAttributeDomainJoinInfo                   FleetAttribute = "DOMAIN_JOIN_INFO"
)

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

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

type FleetErrorCode string

// Enum values for FleetErrorCode
const (
	FleetErrorCodeIamServiceRoleMissingEniDescribeAction            FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"
	FleetErrorCodeIamServiceRoleMissingEniCreateAction              FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_CREATE_ACTION"
	FleetErrorCodeIamServiceRoleMissingEniDeleteAction              FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_DELETE_ACTION"
	FleetErrorCodeNetworkInterfaceLimitExceeded                     FleetErrorCode = "NETWORK_INTERFACE_LIMIT_EXCEEDED"
	FleetErrorCodeInternalServiceError                              FleetErrorCode = "INTERNAL_SERVICE_ERROR"
	FleetErrorCodeIamServiceRoleIsMissing                           FleetErrorCode = "IAM_SERVICE_ROLE_IS_MISSING"
	FleetErrorCodeSubnetHasInsufficientIpAddresses                  FleetErrorCode = "SUBNET_HAS_INSUFFICIENT_IP_ADDRESSES"
	FleetErrorCodeIamServiceRoleMissingDescribeSubnetAction         FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SUBNET_ACTION"
	FleetErrorCodeSubnetNotFound                                    FleetErrorCode = "SUBNET_NOT_FOUND"
	FleetErrorCodeImageNotFound                                     FleetErrorCode = "IMAGE_NOT_FOUND"
	FleetErrorCodeInvalidSubnetConfiguration                        FleetErrorCode = "INVALID_SUBNET_CONFIGURATION"
	FleetErrorCodeSecurityGroupsNotFound                            FleetErrorCode = "SECURITY_GROUPS_NOT_FOUND"
	FleetErrorCodeIgwNotAttached                                    FleetErrorCode = "IGW_NOT_ATTACHED"
	FleetErrorCodeIamServiceRoleMissingDescribeSecurityGroupsAction FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SECURITY_GROUPS_ACTION"
	FleetErrorCodeDomainJoinErrorFileNotFound                       FleetErrorCode = "DOMAIN_JOIN_ERROR_FILE_NOT_FOUND"
	FleetErrorCodeDomainJoinErrorAccessDenied                       FleetErrorCode = "DOMAIN_JOIN_ERROR_ACCESS_DENIED"
	FleetErrorCodeDomainJoinErrorLogonFailure                       FleetErrorCode = "DOMAIN_JOIN_ERROR_LOGON_FAILURE"
	FleetErrorCodeDomainJoinErrorInvalidParameter                   FleetErrorCode = "DOMAIN_JOIN_ERROR_INVALID_PARAMETER"
	FleetErrorCodeDomainJoinErrorMoreData                           FleetErrorCode = "DOMAIN_JOIN_ERROR_MORE_DATA"
	FleetErrorCodeDomainJoinErrorNoSuchDomain                       FleetErrorCode = "DOMAIN_JOIN_ERROR_NO_SUCH_DOMAIN"
	FleetErrorCodeDomainJoinErrorNotSupported                       FleetErrorCode = "DOMAIN_JOIN_ERROR_NOT_SUPPORTED"
	FleetErrorCodeDomainJoinNerrInvalidWorkgroupName                FleetErrorCode = "DOMAIN_JOIN_NERR_INVALID_WORKGROUP_NAME"
	FleetErrorCodeDomainJoinNerrWorkstationNotStarted               FleetErrorCode = "DOMAIN_JOIN_NERR_WORKSTATION_NOT_STARTED"
	FleetErrorCodeDomainJoinErrorDsMachineAccountQuotaExceeded      FleetErrorCode = "DOMAIN_JOIN_ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"
	FleetErrorCodeDomainJoinNerrPasswordExpired                     FleetErrorCode = "DOMAIN_JOIN_NERR_PASSWORD_EXPIRED"
	FleetErrorCodeDomainJoinInternalServiceError                    FleetErrorCode = "DOMAIN_JOIN_INTERNAL_SERVICE_ERROR"
)

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

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

type FleetState string

// Enum values for FleetState
const (
	FleetStateStarting FleetState = "STARTING"
	FleetStateRunning  FleetState = "RUNNING"
	FleetStateStopping FleetState = "STOPPING"
	FleetStateStopped  FleetState = "STOPPED"
)

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

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

type FleetType string

// Enum values for FleetType
const (
	FleetTypeAlwaysOn FleetType = "ALWAYS_ON"
	FleetTypeOnDemand FleetType = "ON_DEMAND"
)

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

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

type ImageBuilderState string

// Enum values for ImageBuilderState
const (
	ImageBuilderStatePending       ImageBuilderState = "PENDING"
	ImageBuilderStateUpdatingAgent ImageBuilderState = "UPDATING_AGENT"
	ImageBuilderStateRunning       ImageBuilderState = "RUNNING"
	ImageBuilderStateStopping      ImageBuilderState = "STOPPING"
	ImageBuilderStateStopped       ImageBuilderState = "STOPPED"
	ImageBuilderStateRebooting     ImageBuilderState = "REBOOTING"
	ImageBuilderStateSnapshotting  ImageBuilderState = "SNAPSHOTTING"
	ImageBuilderStateDeleting      ImageBuilderState = "DELETING"
	ImageBuilderStateFailed        ImageBuilderState = "FAILED"
)

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

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

type ImageBuilderStateChangeReasonCode string

// Enum values for ImageBuilderStateChangeReasonCode
const (
	ImageBuilderStateChangeReasonCodeInternalError    ImageBuilderStateChangeReasonCode = "INTERNAL_ERROR"
	ImageBuilderStateChangeReasonCodeImageUnavailable ImageBuilderStateChangeReasonCode = "IMAGE_UNAVAILABLE"
)

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

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

type ImageState string

// Enum values for ImageState
const (
	ImageStatePending   ImageState = "PENDING"
	ImageStateAvailable ImageState = "AVAILABLE"
	ImageStateFailed    ImageState = "FAILED"
	ImageStateCopying   ImageState = "COPYING"
	ImageStateDeleting  ImageState = "DELETING"
)

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

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

type ImageStateChangeReasonCode string

// Enum values for ImageStateChangeReasonCode
const (
	ImageStateChangeReasonCodeInternalError            ImageStateChangeReasonCode = "INTERNAL_ERROR"
	ImageStateChangeReasonCodeImageBuilderNotAvailable ImageStateChangeReasonCode = "IMAGE_BUILDER_NOT_AVAILABLE"
	ImageStateChangeReasonCodeImageCopyFailure         ImageStateChangeReasonCode = "IMAGE_COPY_FAILURE"
)

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

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

type Permission string

// Enum values for Permission
const (
	PermissionEnabled  Permission = "ENABLED"
	PermissionDisabled Permission = "DISABLED"
)

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

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

type PlatformType string

// Enum values for PlatformType
const (
	PlatformTypeWindows PlatformType = "WINDOWS"
)

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

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

// Possible values for the state of a streaming session.
type SessionState string

// Enum values for SessionState
const (
	SessionStateActive  SessionState = "ACTIVE"
	SessionStatePending SessionState = "PENDING"
	SessionStateExpired SessionState = "EXPIRED"
)

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

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

type StackAttribute string

// Enum values for StackAttribute
const (
	StackAttributeStorageConnectors StackAttribute = "STORAGE_CONNECTORS"
	StackAttributeRedirectUrl       StackAttribute = "REDIRECT_URL"
	StackAttributeFeedbackUrl       StackAttribute = "FEEDBACK_URL"
	StackAttributeThemeName         StackAttribute = "THEME_NAME"
	StackAttributeUserSettings      StackAttribute = "USER_SETTINGS"
)

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

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

type StackErrorCode string

// Enum values for StackErrorCode
const (
	StackErrorCodeStorageConnectorError StackErrorCode = "STORAGE_CONNECTOR_ERROR"
	StackErrorCodeInternalServiceError  StackErrorCode = "INTERNAL_SERVICE_ERROR"
)

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

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

// The type of storage connector.
type StorageConnectorType string

// Enum values for StorageConnectorType
const (
	StorageConnectorTypeHomefolders StorageConnectorType = "HOMEFOLDERS"
)

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

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

type VisibilityType string

// Enum values for VisibilityType
const (
	VisibilityTypePublic  VisibilityType = "PUBLIC"
	VisibilityTypePrivate VisibilityType = "PRIVATE"
)

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

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