api.go

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

package workspaces

import (
	"fmt"
	"time"

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

const opAssociateIpGroups = "AssociateIpGroups"

// AssociateIpGroupsRequest is a API request type for the AssociateIpGroups API operation.
type AssociateIpGroupsRequest struct {
	*aws.Request
	Input *AssociateIpGroupsInput
	Copy  func(*AssociateIpGroupsInput) AssociateIpGroupsRequest
}

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

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

// AssociateIpGroupsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Associates the specified IP access control group with the specified directory.
//
//    // Example sending a request using the AssociateIpGroupsRequest method.
//    req := client.AssociateIpGroupsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AssociateIpGroups
func (c *WorkSpaces) AssociateIpGroupsRequest(input *AssociateIpGroupsInput) AssociateIpGroupsRequest {
	op := &aws.Operation{
		Name:       opAssociateIpGroups,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateIpGroupsInput{}
	}

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

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

const opAuthorizeIpRules = "AuthorizeIpRules"

// AuthorizeIpRulesRequest is a API request type for the AuthorizeIpRules API operation.
type AuthorizeIpRulesRequest struct {
	*aws.Request
	Input *AuthorizeIpRulesInput
	Copy  func(*AuthorizeIpRulesInput) AuthorizeIpRulesRequest
}

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

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

// AuthorizeIpRulesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Adds one or more rules to the specified IP access control group.
//
// This action gives users permission to access their WorkSpaces from the CIDR
// address ranges specified in the rules.
//
//    // Example sending a request using the AuthorizeIpRulesRequest method.
//    req := client.AuthorizeIpRulesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AuthorizeIpRules
func (c *WorkSpaces) AuthorizeIpRulesRequest(input *AuthorizeIpRulesInput) AuthorizeIpRulesRequest {
	op := &aws.Operation{
		Name:       opAuthorizeIpRules,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AuthorizeIpRulesInput{}
	}

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

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

const opCreateIpGroup = "CreateIpGroup"

// CreateIpGroupRequest is a API request type for the CreateIpGroup API operation.
type CreateIpGroupRequest struct {
	*aws.Request
	Input *CreateIpGroupInput
	Copy  func(*CreateIpGroupInput) CreateIpGroupRequest
}

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

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

// CreateIpGroupRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Creates an IP access control group.
//
// An IP access control group provides you with the ability to control the IP
// addresses from which users are allowed to access their WorkSpaces. To specify
// the CIDR address ranges, add rules to your IP access control group and then
// associate the group with your directory. You can add rules when you create
// the group or at any time using AuthorizeIpRules.
//
// There is a default IP access control group associated with your directory.
// If you don't associate an IP access control group with your directory, the
// default group is used. The default group includes a default rule that allows
// users to access their WorkSpaces from anywhere. You cannot modify the default
// IP access control group for your directory.
//
//    // Example sending a request using the CreateIpGroupRequest method.
//    req := client.CreateIpGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateIpGroup
func (c *WorkSpaces) CreateIpGroupRequest(input *CreateIpGroupInput) CreateIpGroupRequest {
	op := &aws.Operation{
		Name:       opCreateIpGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateIpGroupInput{}
	}

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

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

const opCreateTags = "CreateTags"

// CreateTagsRequest is a API request type for the CreateTags API operation.
type CreateTagsRequest struct {
	*aws.Request
	Input *CreateTagsInput
	Copy  func(*CreateTagsInput) CreateTagsRequest
}

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

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

// CreateTagsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Creates the specified tags for the specified WorkSpace.
//
//    // Example sending a request using the CreateTagsRequest method.
//    req := client.CreateTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateTags
func (c *WorkSpaces) CreateTagsRequest(input *CreateTagsInput) CreateTagsRequest {
	op := &aws.Operation{
		Name:       opCreateTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateTagsInput{}
	}

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

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

const opCreateWorkspaces = "CreateWorkspaces"

// CreateWorkspacesRequest is a API request type for the CreateWorkspaces API operation.
type CreateWorkspacesRequest struct {
	*aws.Request
	Input *CreateWorkspacesInput
	Copy  func(*CreateWorkspacesInput) CreateWorkspacesRequest
}

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

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

// CreateWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Creates one or more WorkSpaces.
//
// This operation is asynchronous and returns before the WorkSpaces are created.
//
//    // Example sending a request using the CreateWorkspacesRequest method.
//    req := client.CreateWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateWorkspaces
func (c *WorkSpaces) CreateWorkspacesRequest(input *CreateWorkspacesInput) CreateWorkspacesRequest {
	op := &aws.Operation{
		Name:       opCreateWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateWorkspacesInput{}
	}

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

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

const opDeleteIpGroup = "DeleteIpGroup"

// DeleteIpGroupRequest is a API request type for the DeleteIpGroup API operation.
type DeleteIpGroupRequest struct {
	*aws.Request
	Input *DeleteIpGroupInput
	Copy  func(*DeleteIpGroupInput) DeleteIpGroupRequest
}

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

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

// DeleteIpGroupRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Deletes the specified IP access control group.
//
// You cannot delete an IP access control group that is associated with a directory.
//
//    // Example sending a request using the DeleteIpGroupRequest method.
//    req := client.DeleteIpGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteIpGroup
func (c *WorkSpaces) DeleteIpGroupRequest(input *DeleteIpGroupInput) DeleteIpGroupRequest {
	op := &aws.Operation{
		Name:       opDeleteIpGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteIpGroupInput{}
	}

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

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

const opDeleteTags = "DeleteTags"

// DeleteTagsRequest is a API request type for the DeleteTags API operation.
type DeleteTagsRequest struct {
	*aws.Request
	Input *DeleteTagsInput
	Copy  func(*DeleteTagsInput) DeleteTagsRequest
}

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

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

// DeleteTagsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Deletes the specified tags from the specified WorkSpace.
//
//    // Example sending a request using the DeleteTagsRequest method.
//    req := client.DeleteTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteTags
func (c *WorkSpaces) DeleteTagsRequest(input *DeleteTagsInput) DeleteTagsRequest {
	op := &aws.Operation{
		Name:       opDeleteTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteTagsInput{}
	}

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

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

const opDescribeIpGroups = "DescribeIpGroups"

// DescribeIpGroupsRequest is a API request type for the DescribeIpGroups API operation.
type DescribeIpGroupsRequest struct {
	*aws.Request
	Input *DescribeIpGroupsInput
	Copy  func(*DescribeIpGroupsInput) DescribeIpGroupsRequest
}

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

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

// DescribeIpGroupsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes one or more of your IP access control groups.
//
//    // Example sending a request using the DescribeIpGroupsRequest method.
//    req := client.DescribeIpGroupsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeIpGroups
func (c *WorkSpaces) DescribeIpGroupsRequest(input *DescribeIpGroupsInput) DescribeIpGroupsRequest {
	op := &aws.Operation{
		Name:       opDescribeIpGroups,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeIpGroupsInput{}
	}

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

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

const opDescribeTags = "DescribeTags"

// DescribeTagsRequest is a API request type for the DescribeTags API operation.
type DescribeTagsRequest struct {
	*aws.Request
	Input *DescribeTagsInput
	Copy  func(*DescribeTagsInput) DescribeTagsRequest
}

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

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

// DescribeTagsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes the specified tags for the specified WorkSpace.
//
//    // Example sending a request using the DescribeTagsRequest method.
//    req := client.DescribeTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeTags
func (c *WorkSpaces) DescribeTagsRequest(input *DescribeTagsInput) DescribeTagsRequest {
	op := &aws.Operation{
		Name:       opDescribeTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeTagsInput{}
	}

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

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

const opDescribeWorkspaceBundles = "DescribeWorkspaceBundles"

// DescribeWorkspaceBundlesRequest is a API request type for the DescribeWorkspaceBundles API operation.
type DescribeWorkspaceBundlesRequest struct {
	*aws.Request
	Input *DescribeWorkspaceBundlesInput
	Copy  func(*DescribeWorkspaceBundlesInput) DescribeWorkspaceBundlesRequest
}

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

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

// DescribeWorkspaceBundlesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes the available WorkSpace bundles.
//
// You can filter the results using either bundle ID or owner, but not both.
//
//    // Example sending a request using the DescribeWorkspaceBundlesRequest method.
//    req := client.DescribeWorkspaceBundlesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspaceBundles
func (c *WorkSpaces) DescribeWorkspaceBundlesRequest(input *DescribeWorkspaceBundlesInput) DescribeWorkspaceBundlesRequest {
	op := &aws.Operation{
		Name:       opDescribeWorkspaceBundles,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &DescribeWorkspaceBundlesInput{}
	}

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

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

// Paginate pages iterates over the pages of a DescribeWorkspaceBundlesRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a DescribeWorkspaceBundles operation.
//		req := client.DescribeWorkspaceBundlesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *DescribeWorkspaceBundlesRequest) Paginate(opts ...aws.Option) DescribeWorkspaceBundlesPager {
	return DescribeWorkspaceBundlesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *DescribeWorkspaceBundlesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// DescribeWorkspaceBundlesPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type DescribeWorkspaceBundlesPager struct {
	aws.Pager
}

func (p *DescribeWorkspaceBundlesPager) CurrentPage() *DescribeWorkspaceBundlesOutput {
	return p.Pager.CurrentPage().(*DescribeWorkspaceBundlesOutput)
}

const opDescribeWorkspaceDirectories = "DescribeWorkspaceDirectories"

// DescribeWorkspaceDirectoriesRequest is a API request type for the DescribeWorkspaceDirectories API operation.
type DescribeWorkspaceDirectoriesRequest struct {
	*aws.Request
	Input *DescribeWorkspaceDirectoriesInput
	Copy  func(*DescribeWorkspaceDirectoriesInput) DescribeWorkspaceDirectoriesRequest
}

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

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

// DescribeWorkspaceDirectoriesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes the available AWS Directory Service directories that are registered
// with Amazon WorkSpaces.
//
//    // Example sending a request using the DescribeWorkspaceDirectoriesRequest method.
//    req := client.DescribeWorkspaceDirectoriesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspaceDirectories
func (c *WorkSpaces) DescribeWorkspaceDirectoriesRequest(input *DescribeWorkspaceDirectoriesInput) DescribeWorkspaceDirectoriesRequest {
	op := &aws.Operation{
		Name:       opDescribeWorkspaceDirectories,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &DescribeWorkspaceDirectoriesInput{}
	}

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

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

// Paginate pages iterates over the pages of a DescribeWorkspaceDirectoriesRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a DescribeWorkspaceDirectories operation.
//		req := client.DescribeWorkspaceDirectoriesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *DescribeWorkspaceDirectoriesRequest) Paginate(opts ...aws.Option) DescribeWorkspaceDirectoriesPager {
	return DescribeWorkspaceDirectoriesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *DescribeWorkspaceDirectoriesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// DescribeWorkspaceDirectoriesPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type DescribeWorkspaceDirectoriesPager struct {
	aws.Pager
}

func (p *DescribeWorkspaceDirectoriesPager) CurrentPage() *DescribeWorkspaceDirectoriesOutput {
	return p.Pager.CurrentPage().(*DescribeWorkspaceDirectoriesOutput)
}

const opDescribeWorkspaces = "DescribeWorkspaces"

// DescribeWorkspacesRequest is a API request type for the DescribeWorkspaces API operation.
type DescribeWorkspacesRequest struct {
	*aws.Request
	Input *DescribeWorkspacesInput
	Copy  func(*DescribeWorkspacesInput) DescribeWorkspacesRequest
}

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

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

// DescribeWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes the specified WorkSpaces.
//
// You can filter the results using bundle ID, directory ID, or owner, but you
// can specify only one filter at a time.
//
//    // Example sending a request using the DescribeWorkspacesRequest method.
//    req := client.DescribeWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspaces
func (c *WorkSpaces) DescribeWorkspacesRequest(input *DescribeWorkspacesInput) DescribeWorkspacesRequest {
	op := &aws.Operation{
		Name:       opDescribeWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "Limit",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &DescribeWorkspacesInput{}
	}

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

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

// Paginate pages iterates over the pages of a DescribeWorkspacesRequest operation,
// calling the Next method for each page. Using the paginators Next
// method will depict whether or not there are more pages.
//
// Note: This operation can generate multiple requests to a service.
//
//    // Example iterating over at most 3 pages of a DescribeWorkspaces operation.
//		req := client.DescribeWorkspacesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *DescribeWorkspacesRequest) Paginate(opts ...aws.Option) DescribeWorkspacesPager {
	return DescribeWorkspacesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *DescribeWorkspacesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

				req := p.Copy(inCpy)
				req.ApplyOptions(opts...)

				return req.Request, nil
			},
		},
	}
}

// DescribeWorkspacesPager is used to paginate the request. This can be done by
// calling Next and CurrentPage.
type DescribeWorkspacesPager struct {
	aws.Pager
}

func (p *DescribeWorkspacesPager) CurrentPage() *DescribeWorkspacesOutput {
	return p.Pager.CurrentPage().(*DescribeWorkspacesOutput)
}

const opDescribeWorkspacesConnectionStatus = "DescribeWorkspacesConnectionStatus"

// DescribeWorkspacesConnectionStatusRequest is a API request type for the DescribeWorkspacesConnectionStatus API operation.
type DescribeWorkspacesConnectionStatusRequest struct {
	*aws.Request
	Input *DescribeWorkspacesConnectionStatusInput
	Copy  func(*DescribeWorkspacesConnectionStatusInput) DescribeWorkspacesConnectionStatusRequest
}

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

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

// DescribeWorkspacesConnectionStatusRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Describes the connection status of the specified WorkSpaces.
//
//    // Example sending a request using the DescribeWorkspacesConnectionStatusRequest method.
//    req := client.DescribeWorkspacesConnectionStatusRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspacesConnectionStatus
func (c *WorkSpaces) DescribeWorkspacesConnectionStatusRequest(input *DescribeWorkspacesConnectionStatusInput) DescribeWorkspacesConnectionStatusRequest {
	op := &aws.Operation{
		Name:       opDescribeWorkspacesConnectionStatus,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeWorkspacesConnectionStatusInput{}
	}

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

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

const opDisassociateIpGroups = "DisassociateIpGroups"

// DisassociateIpGroupsRequest is a API request type for the DisassociateIpGroups API operation.
type DisassociateIpGroupsRequest struct {
	*aws.Request
	Input *DisassociateIpGroupsInput
	Copy  func(*DisassociateIpGroupsInput) DisassociateIpGroupsRequest
}

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

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

// DisassociateIpGroupsRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Disassociates the specified IP access control group from the specified directory.
//
//    // Example sending a request using the DisassociateIpGroupsRequest method.
//    req := client.DisassociateIpGroupsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DisassociateIpGroups
func (c *WorkSpaces) DisassociateIpGroupsRequest(input *DisassociateIpGroupsInput) DisassociateIpGroupsRequest {
	op := &aws.Operation{
		Name:       opDisassociateIpGroups,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateIpGroupsInput{}
	}

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

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

const opModifyWorkspaceProperties = "ModifyWorkspaceProperties"

// ModifyWorkspacePropertiesRequest is a API request type for the ModifyWorkspaceProperties API operation.
type ModifyWorkspacePropertiesRequest struct {
	*aws.Request
	Input *ModifyWorkspacePropertiesInput
	Copy  func(*ModifyWorkspacePropertiesInput) ModifyWorkspacePropertiesRequest
}

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

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

// ModifyWorkspacePropertiesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Modifies the specified WorkSpace properties.
//
//    // Example sending a request using the ModifyWorkspacePropertiesRequest method.
//    req := client.ModifyWorkspacePropertiesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspaceProperties
func (c *WorkSpaces) ModifyWorkspacePropertiesRequest(input *ModifyWorkspacePropertiesInput) ModifyWorkspacePropertiesRequest {
	op := &aws.Operation{
		Name:       opModifyWorkspaceProperties,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ModifyWorkspacePropertiesInput{}
	}

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

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

const opModifyWorkspaceState = "ModifyWorkspaceState"

// ModifyWorkspaceStateRequest is a API request type for the ModifyWorkspaceState API operation.
type ModifyWorkspaceStateRequest struct {
	*aws.Request
	Input *ModifyWorkspaceStateInput
	Copy  func(*ModifyWorkspaceStateInput) ModifyWorkspaceStateRequest
}

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

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

// ModifyWorkspaceStateRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Sets the state of the specified WorkSpace.
//
// To maintain a WorkSpace without being interrupted, set the WorkSpace state
// to ADMIN_MAINTENANCE. WorkSpaces in this state do not respond to requests
// to reboot, stop, start, or rebuild. An AutoStop WorkSpace in this state is
// not stopped. Users can log into a WorkSpace in the ADMIN_MAINTENANCE state.
//
//    // Example sending a request using the ModifyWorkspaceStateRequest method.
//    req := client.ModifyWorkspaceStateRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspaceState
func (c *WorkSpaces) ModifyWorkspaceStateRequest(input *ModifyWorkspaceStateInput) ModifyWorkspaceStateRequest {
	op := &aws.Operation{
		Name:       opModifyWorkspaceState,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ModifyWorkspaceStateInput{}
	}

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

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

const opRebootWorkspaces = "RebootWorkspaces"

// RebootWorkspacesRequest is a API request type for the RebootWorkspaces API operation.
type RebootWorkspacesRequest struct {
	*aws.Request
	Input *RebootWorkspacesInput
	Copy  func(*RebootWorkspacesInput) RebootWorkspacesRequest
}

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

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

// RebootWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Reboots the specified WorkSpaces.
//
// You cannot reboot a WorkSpace unless its state is AVAILABLE or UNHEALTHY.
//
// This operation is asynchronous and returns before the WorkSpaces have rebooted.
//
//    // Example sending a request using the RebootWorkspacesRequest method.
//    req := client.RebootWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebootWorkspaces
func (c *WorkSpaces) RebootWorkspacesRequest(input *RebootWorkspacesInput) RebootWorkspacesRequest {
	op := &aws.Operation{
		Name:       opRebootWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RebootWorkspacesInput{}
	}

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

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

const opRebuildWorkspaces = "RebuildWorkspaces"

// RebuildWorkspacesRequest is a API request type for the RebuildWorkspaces API operation.
type RebuildWorkspacesRequest struct {
	*aws.Request
	Input *RebuildWorkspacesInput
	Copy  func(*RebuildWorkspacesInput) RebuildWorkspacesRequest
}

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

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

// RebuildWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Rebuilds the specified WorkSpace.
//
// You cannot rebuild a WorkSpace unless its state is AVAILABLE, ERROR, or UNHEALTHY.
//
// Rebuilding a WorkSpace is a potentially destructive action that can result
// in the loss of data. For more information, see Rebuild a WorkSpace (http://docs.aws.amazon.com/workspaces/latest/adminguide/reset-workspace.html).
//
// This operation is asynchronous and returns before the WorkSpaces have been
// completely rebuilt.
//
//    // Example sending a request using the RebuildWorkspacesRequest method.
//    req := client.RebuildWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebuildWorkspaces
func (c *WorkSpaces) RebuildWorkspacesRequest(input *RebuildWorkspacesInput) RebuildWorkspacesRequest {
	op := &aws.Operation{
		Name:       opRebuildWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RebuildWorkspacesInput{}
	}

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

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

const opRevokeIpRules = "RevokeIpRules"

// RevokeIpRulesRequest is a API request type for the RevokeIpRules API operation.
type RevokeIpRulesRequest struct {
	*aws.Request
	Input *RevokeIpRulesInput
	Copy  func(*RevokeIpRulesInput) RevokeIpRulesRequest
}

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

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

// RevokeIpRulesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Removes one or more rules from the specified IP access control group.
//
//    // Example sending a request using the RevokeIpRulesRequest method.
//    req := client.RevokeIpRulesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RevokeIpRules
func (c *WorkSpaces) RevokeIpRulesRequest(input *RevokeIpRulesInput) RevokeIpRulesRequest {
	op := &aws.Operation{
		Name:       opRevokeIpRules,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RevokeIpRulesInput{}
	}

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

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

const opStartWorkspaces = "StartWorkspaces"

// StartWorkspacesRequest is a API request type for the StartWorkspaces API operation.
type StartWorkspacesRequest struct {
	*aws.Request
	Input *StartWorkspacesInput
	Copy  func(*StartWorkspacesInput) StartWorkspacesRequest
}

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

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

// StartWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Starts the specified WorkSpaces.
//
// You cannot start a WorkSpace unless it has a running mode of AutoStop and
// a state of STOPPED.
//
//    // Example sending a request using the StartWorkspacesRequest method.
//    req := client.StartWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StartWorkspaces
func (c *WorkSpaces) StartWorkspacesRequest(input *StartWorkspacesInput) StartWorkspacesRequest {
	op := &aws.Operation{
		Name:       opStartWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartWorkspacesInput{}
	}

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

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

const opStopWorkspaces = "StopWorkspaces"

// StopWorkspacesRequest is a API request type for the StopWorkspaces API operation.
type StopWorkspacesRequest struct {
	*aws.Request
	Input *StopWorkspacesInput
	Copy  func(*StopWorkspacesInput) StopWorkspacesRequest
}

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

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

// StopWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Stops the specified WorkSpaces.
//
// You cannot stop a WorkSpace unless it has a running mode of AutoStop and
// a state of AVAILABLE, IMPAIRED, UNHEALTHY, or ERROR.
//
//    // Example sending a request using the StopWorkspacesRequest method.
//    req := client.StopWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StopWorkspaces
func (c *WorkSpaces) StopWorkspacesRequest(input *StopWorkspacesInput) StopWorkspacesRequest {
	op := &aws.Operation{
		Name:       opStopWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StopWorkspacesInput{}
	}

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

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

const opTerminateWorkspaces = "TerminateWorkspaces"

// TerminateWorkspacesRequest is a API request type for the TerminateWorkspaces API operation.
type TerminateWorkspacesRequest struct {
	*aws.Request
	Input *TerminateWorkspacesInput
	Copy  func(*TerminateWorkspacesInput) TerminateWorkspacesRequest
}

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

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

// TerminateWorkspacesRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Terminates the specified WorkSpaces.
//
// Terminating a WorkSpace is a permanent action and cannot be undone. The user's
// data is destroyed. If you need to archive any user data, contact Amazon Web
// Services before terminating the WorkSpace.
//
// You can terminate a WorkSpace that is in any state except SUSPENDED.
//
// This operation is asynchronous and returns before the WorkSpaces have been
// completely terminated.
//
//    // Example sending a request using the TerminateWorkspacesRequest method.
//    req := client.TerminateWorkspacesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/TerminateWorkspaces
func (c *WorkSpaces) TerminateWorkspacesRequest(input *TerminateWorkspacesInput) TerminateWorkspacesRequest {
	op := &aws.Operation{
		Name:       opTerminateWorkspaces,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &TerminateWorkspacesInput{}
	}

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

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

const opUpdateRulesOfIpGroup = "UpdateRulesOfIpGroup"

// UpdateRulesOfIpGroupRequest is a API request type for the UpdateRulesOfIpGroup API operation.
type UpdateRulesOfIpGroupRequest struct {
	*aws.Request
	Input *UpdateRulesOfIpGroupInput
	Copy  func(*UpdateRulesOfIpGroupInput) UpdateRulesOfIpGroupRequest
}

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

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

// UpdateRulesOfIpGroupRequest returns a request value for making API operation for
// Amazon WorkSpaces.
//
// Replaces the current rules of the specified IP access control group with
// the specified rules.
//
//    // Example sending a request using the UpdateRulesOfIpGroupRequest method.
//    req := client.UpdateRulesOfIpGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/UpdateRulesOfIpGroup
func (c *WorkSpaces) UpdateRulesOfIpGroupRequest(input *UpdateRulesOfIpGroupInput) UpdateRulesOfIpGroupRequest {
	op := &aws.Operation{
		Name:       opUpdateRulesOfIpGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateRulesOfIpGroupInput{}
	}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AssociateIpGroupsRequest
type AssociateIpGroupsInput struct {
	_ struct{} `type:"structure"`

	// The ID of the directory.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The IDs of one or more IP access control groups.
	//
	// GroupIds is a required field
	GroupIds []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AssociateIpGroupsResult
type AssociateIpGroupsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AuthorizeIpRulesRequest
type AuthorizeIpRulesInput struct {
	_ struct{} `type:"structure"`

	// The ID of the group.
	//
	// GroupId is a required field
	GroupId *string `type:"string" required:"true"`

	// The rules to add to the group.
	//
	// UserRules is a required field
	UserRules []IpRuleItem `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/AuthorizeIpRulesResult
type AuthorizeIpRulesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information about the compute type.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ComputeType
type ComputeType struct {
	_ struct{} `type:"structure"`

	// The compute type.
	Name Compute `type:"string" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateIpGroupRequest
type CreateIpGroupInput struct {
	_ struct{} `type:"structure"`

	// The description of the group.
	GroupDesc *string `type:"string"`

	// The name of the group.
	//
	// GroupName is a required field
	GroupName *string `type:"string" required:"true"`

	// The rules to add to the group.
	UserRules []IpRuleItem `type:"list"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateIpGroupResult
type CreateIpGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ID of the group.
	GroupId *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateTagsRequest
type CreateTagsInput struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace. To find this ID, use DescribeWorkspaces.
	//
	// ResourceId is a required field
	ResourceId *string `min:"1" type:"string" required:"true"`

	// The tags. Each WorkSpace can have a maximum of 50 tags.
	//
	// Tags is a required field
	Tags []Tag `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateTagsResult
type CreateTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateWorkspacesRequest
type CreateWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpaces to create. You can specify up to 25 WorkSpaces.
	//
	// Workspaces is a required field
	Workspaces []WorkspaceRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/CreateWorkspacesResult
type CreateWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpaces that could not be created.
	FailedRequests []FailedCreateWorkspaceRequest `type:"list"`

	// Information about the WorkSpaces that were created.
	//
	// Because this operation is asynchronous, the identifier returned is not immediately
	// available for use with other operations. For example, if you call DescribeWorkspaces
	// before the WorkSpace is created, the information returned can be incomplete.
	PendingRequests []Workspace `type:"list"`
}

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

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

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

// Information about defaults used to create a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DefaultWorkspaceCreationProperties
type DefaultWorkspaceCreationProperties struct {
	_ struct{} `type:"structure"`

	// The identifier of any security groups to apply to WorkSpaces when they are
	// created.
	CustomSecurityGroupId *string `type:"string"`

	// The organizational unit (OU) in the directory for the WorkSpace machine accounts.
	DefaultOu *string `type:"string"`

	// The public IP address to attach to all WorkSpaces that are created or rebuilt.
	EnableInternetAccess *bool `type:"boolean"`

	// Indicates whether the directory is enabled for Amazon WorkDocs.
	EnableWorkDocs *bool `type:"boolean"`

	// Indicates whether the WorkSpace user is an administrator on the WorkSpace.
	UserEnabledAsLocalAdministrator *bool `type:"boolean"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteIpGroupRequest
type DeleteIpGroupInput struct {
	_ struct{} `type:"structure"`

	// The ID of the IP access control group.
	//
	// GroupId is a required field
	GroupId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteIpGroupResult
type DeleteIpGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteTagsRequest
type DeleteTagsInput struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace. To find this ID, use DescribeWorkspaces.
	//
	// ResourceId is a required field
	ResourceId *string `min:"1" type:"string" required:"true"`

	// The tag keys.
	//
	// TagKeys is a required field
	TagKeys []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DeleteTagsResult
type DeleteTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeIpGroupsRequest
type DescribeIpGroupsInput struct {
	_ struct{} `type:"structure"`

	// The IDs of one or more IP access control groups.
	GroupIds []string `type:"list"`

	// The maximum number of items to return.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token for the next set of results. (You received this token from a previous
	// call.)
	NextToken *string `min:"1" type:"string"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeIpGroupsResult
type DescribeIpGroupsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next set of results, or null if there are
	// no more results available. This token is valid for one day and must be used
	// within that time frame.
	NextToken *string `min:"1" type:"string"`

	// Information about the IP access control groups.
	Result []IpGroup `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeTagsRequest
type DescribeTagsInput struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace. To find this ID, use DescribeWorkspaces.
	//
	// ResourceId is a required field
	ResourceId *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeTagsResult
type DescribeTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The tags.
	TagList []Tag `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspaceBundlesRequest
type DescribeWorkspaceBundlesInput struct {
	_ struct{} `type:"structure"`

	// The IDs of the bundles. This parameter cannot be combined with any other
	// filter.
	BundleIds []string `min:"1" type:"list"`

	// The token for the next set of results. (You received this token from a previous
	// call.)
	NextToken *string `min:"1" type:"string"`

	// The owner of the bundles. This parameter cannot be combined with any other
	// filter.
	//
	// Specify AMAZON to describe the bundles provided by AWS or null to describe
	// the bundles that belong to your account.
	Owner *string `type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeWorkspaceBundlesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeWorkspaceBundlesInput"}
	if s.BundleIds != nil && len(s.BundleIds) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("BundleIds", 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/workspaces-2015-04-08/DescribeWorkspaceBundlesResult
type DescribeWorkspaceBundlesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the bundles.
	Bundles []WorkspaceBundle `type:"list"`

	// The token to use to retrieve the next set of results, or null if there are
	// no more results available. This token is valid for one day and must be used
	// within that time frame.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspaceDirectoriesRequest
type DescribeWorkspaceDirectoriesInput struct {
	_ struct{} `type:"structure"`

	// The identifiers of the directories. If the value is null, all directories
	// are retrieved.
	DirectoryIds []string `min:"1" type:"list"`

	// The token for the next set of results. (You received this token from a previous
	// call.)
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *DescribeWorkspaceDirectoriesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DescribeWorkspaceDirectoriesInput"}
	if s.DirectoryIds != nil && len(s.DirectoryIds) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("DirectoryIds", 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/workspaces-2015-04-08/DescribeWorkspaceDirectoriesResult
type DescribeWorkspaceDirectoriesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the directories.
	Directories []WorkspaceDirectory `type:"list"`

	// The token to use to retrieve the next set of results, or null if there are
	// no more results available. This token is valid for one day and must be used
	// within that time frame.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspacesConnectionStatusRequest
type DescribeWorkspacesConnectionStatusInput struct {
	_ struct{} `type:"structure"`

	// The token for the next set of results. (You received this token from a previous
	// call.)
	NextToken *string `min:"1" type:"string"`

	// The identifiers of the WorkSpaces. You can specify up to 25 WorkSpaces.
	WorkspaceIds []string `min:"1" type:"list"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspacesConnectionStatusResult
type DescribeWorkspacesConnectionStatusOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next set of results, or null if there are
	// no more results available.
	NextToken *string `min:"1" type:"string"`

	// Information about the connection status of the WorkSpace.
	WorkspacesConnectionStatus []WorkspaceConnectionStatus `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspacesRequest
type DescribeWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The ID of the bundle. All WorkSpaces that are created from this bundle are
	// retrieved. This parameter cannot be combined with any other filter.
	BundleId *string `type:"string"`

	// The ID of the directory. In addition, you can optionally specify a specific
	// directory user (see UserName). This parameter cannot be combined with any
	// other filter.
	DirectoryId *string `type:"string"`

	// The maximum number of items to return.
	Limit *int64 `min:"1" type:"integer"`

	// The token for the next set of results. (You received this token from a previous
	// call.)
	NextToken *string `min:"1" type:"string"`

	// The name of the directory user. You must specify this parameter with DirectoryId.
	UserName *string `min:"1" type:"string"`

	// The IDs of the WorkSpaces. This parameter cannot be combined with any other
	// filter.
	//
	// Because the CreateWorkspaces operation is asynchronous, the identifier it
	// returns is not immediately available. If you immediately call DescribeWorkspaces
	// with this identifier, no information is returned.
	WorkspaceIds []string `min:"1" type:"list"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DescribeWorkspacesResult
type DescribeWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next set of results, or null if there are
	// no more results available. This token is valid for one day and must be used
	// within that time frame.
	NextToken *string `min:"1" type:"string"`

	// Information about the WorkSpaces.
	//
	// Because CreateWorkspaces is an asynchronous operation, some of the returned
	// information could be incomplete.
	Workspaces []Workspace `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DisassociateIpGroupsRequest
type DisassociateIpGroupsInput struct {
	_ struct{} `type:"structure"`

	// The ID of the directory.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// The IDs of one or more IP access control groups.
	//
	// GroupIds is a required field
	GroupIds []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/DisassociateIpGroupsResult
type DisassociateIpGroupsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information about a WorkSpace that could not be created.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/FailedCreateWorkspaceRequest
type FailedCreateWorkspaceRequest struct {
	_ struct{} `type:"structure"`

	// The error code.
	ErrorCode *string `type:"string"`

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

	// Information about the WorkSpace.
	WorkspaceRequest *WorkspaceRequest `type:"structure"`
}

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

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

// Information about a WorkSpace that could not be rebooted (RebootWorkspaces),
// rebuilt (RebuildWorkspaces), terminated (TerminateWorkspaces), started (StartWorkspaces),
// or stopped (StopWorkspaces).
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/FailedWorkspaceChangeRequest
type FailedWorkspaceChangeRequest struct {
	_ struct{} `type:"structure"`

	// The error code.
	ErrorCode *string `type:"string"`

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

	// The identifier of the WorkSpace.
	WorkspaceId *string `type:"string"`
}

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

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

// Information about an IP access control group.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspacesIpGroup
type IpGroup struct {
	_ struct{} `type:"structure"`

	// The description of the group.
	GroupDesc *string `locationName:"groupDesc" type:"string"`

	// The ID of the group.
	GroupId *string `locationName:"groupId" type:"string"`

	// The name of the group.
	GroupName *string `locationName:"groupName" type:"string"`

	// The rules.
	UserRules []IpRuleItem `locationName:"userRules" type:"list"`
}

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

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

// Information about a rule for an IP access control group.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/IpRuleItem
type IpRuleItem struct {
	_ struct{} `type:"structure"`

	// The IP address range, in CIDR notation.
	IpRule *string `locationName:"ipRule" type:"string"`

	// The description.
	RuleDesc *string `locationName:"ruleDesc" type:"string"`
}

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

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

// Information about a WorkSpace modification.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModificationState
type ModificationState struct {
	_ struct{} `type:"structure"`

	// The resource.
	Resource ModificationResourceEnum `type:"string" enum:"true"`

	// The modification state.
	State ModificationStateEnum `type:"string" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspacePropertiesRequest
type ModifyWorkspacePropertiesInput struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	//
	// WorkspaceId is a required field
	WorkspaceId *string `type:"string" required:"true"`

	// The properties of the WorkSpace.
	//
	// WorkspaceProperties is a required field
	WorkspaceProperties *WorkspaceProperties `type:"structure" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspacePropertiesResult
type ModifyWorkspacePropertiesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspaceStateRequest
type ModifyWorkspaceStateInput struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	//
	// WorkspaceId is a required field
	WorkspaceId *string `type:"string" required:"true"`

	// The WorkSpace state.
	//
	// WorkspaceState is a required field
	WorkspaceState TargetWorkspaceState `type:"string" required:"true" enum:"true"`
}

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

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

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

	if s.WorkspaceId == nil {
		invalidParams.Add(aws.NewErrParamRequired("WorkspaceId"))
	}
	if len(s.WorkspaceState) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("WorkspaceState"))
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/ModifyWorkspaceStateResult
type ModifyWorkspaceStateOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information used to reboot a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebootRequest
type RebootRequest struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	//
	// WorkspaceId is a required field
	WorkspaceId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebootWorkspacesRequest
type RebootWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpaces to reboot. You can specify up to 25 WorkSpaces.
	//
	// RebootWorkspaceRequests is a required field
	RebootWorkspaceRequests []RebootRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebootWorkspacesResult
type RebootWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpaces that could not be rebooted.
	FailedRequests []FailedWorkspaceChangeRequest `type:"list"`
}

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

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

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

// Information used to rebuild a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebuildRequest
type RebuildRequest struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	//
	// WorkspaceId is a required field
	WorkspaceId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebuildWorkspacesRequest
type RebuildWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpace to rebuild. You can specify a single WorkSpace.
	//
	// RebuildWorkspaceRequests is a required field
	RebuildWorkspaceRequests []RebuildRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RebuildWorkspacesResult
type RebuildWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpace if it could not be rebuilt.
	FailedRequests []FailedWorkspaceChangeRequest `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RevokeIpRulesRequest
type RevokeIpRulesInput struct {
	_ struct{} `type:"structure"`

	// The ID of the group.
	//
	// GroupId is a required field
	GroupId *string `type:"string" required:"true"`

	// The rules to remove from the group.
	//
	// UserRules is a required field
	UserRules []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RevokeIpRulesResult
type RevokeIpRulesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information about the root volume for a WorkSpace bundle.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/RootStorage
type RootStorage struct {
	_ struct{} `type:"structure"`

	// The size of the root volume.
	Capacity *string `min:"1" type:"string"`
}

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

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

// Information used to start a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StartRequest
type StartRequest struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	WorkspaceId *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StartWorkspacesRequest
type StartWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpaces to start. You can specify up to 25 WorkSpaces.
	//
	// StartWorkspaceRequests is a required field
	StartWorkspaceRequests []StartRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StartWorkspacesResult
type StartWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpaces that could not be started.
	FailedRequests []FailedWorkspaceChangeRequest `type:"list"`
}

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

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

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

// Information used to stop a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StopRequest
type StopRequest struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	WorkspaceId *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StopWorkspacesRequest
type StopWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpaces to stop. You can specify up to 25 WorkSpaces.
	//
	// StopWorkspaceRequests is a required field
	StopWorkspaceRequests []StopRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/StopWorkspacesResult
type StopWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpaces that could not be stopped.
	FailedRequests []FailedWorkspaceChangeRequest `type:"list"`
}

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

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

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

// Information about a tag.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/Tag
type Tag struct {
	_ struct{} `type:"structure"`

	// The key of the tag.
	//
	// Key is a required field
	Key *string `min:"1" type:"string" required:"true"`

	// The value of the tag.
	Value *string `type:"string"`
}

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

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

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

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

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

// Information used to terminate a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/TerminateRequest
type TerminateRequest struct {
	_ struct{} `type:"structure"`

	// The ID of the WorkSpace.
	//
	// WorkspaceId is a required field
	WorkspaceId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/TerminateWorkspacesRequest
type TerminateWorkspacesInput struct {
	_ struct{} `type:"structure"`

	// The WorkSpaces to terminate. You can specify up to 25 WorkSpaces.
	//
	// TerminateWorkspaceRequests is a required field
	TerminateWorkspaceRequests []TerminateRequest `min:"1" type:"list" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/TerminateWorkspacesResult
type TerminateWorkspacesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WorkSpaces that could not be terminated.
	FailedRequests []FailedWorkspaceChangeRequest `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/UpdateRulesOfIpGroupRequest
type UpdateRulesOfIpGroupInput struct {
	_ struct{} `type:"structure"`

	// The ID of the group.
	//
	// GroupId is a required field
	GroupId *string `type:"string" required:"true"`

	// One or more rules.
	//
	// UserRules is a required field
	UserRules []IpRuleItem `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/UpdateRulesOfIpGroupResult
type UpdateRulesOfIpGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information about the user storage for a WorkSpace bundle.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/UserStorage
type UserStorage struct {
	_ struct{} `type:"structure"`

	// The size of the user storage.
	Capacity *string `min:"1" type:"string"`
}

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

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

// Information about a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/Workspace
type Workspace struct {
	_ struct{} `type:"structure"`

	// The identifier of the bundle used to create the WorkSpace.
	BundleId *string `type:"string"`

	// The name of the WorkSpace, as seen by the operating system.
	ComputerName *string `type:"string"`

	// The identifier of the AWS Directory Service directory for the WorkSpace.
	DirectoryId *string `type:"string"`

	// If the WorkSpace could not be created, contains the error code.
	ErrorCode *string `type:"string"`

	// If the WorkSpace could not be created, contains a textual error message that
	// describes the failure.
	ErrorMessage *string `type:"string"`

	// The IP address of the WorkSpace.
	IpAddress *string `type:"string"`

	// The modification states of the WorkSpace.
	ModificationStates []ModificationState `type:"list"`

	// Indicates whether the data stored on the root volume is encrypted.
	RootVolumeEncryptionEnabled *bool `type:"boolean"`

	// The operational state of the WorkSpace.
	State WorkspaceState `type:"string" enum:"true"`

	// The identifier of the subnet for the WorkSpace.
	SubnetId *string `type:"string"`

	// The user for the WorkSpace.
	UserName *string `min:"1" type:"string"`

	// Indicates whether the data stored on the user volume is encrypted.
	UserVolumeEncryptionEnabled *bool `type:"boolean"`

	// The KMS key used to encrypt data stored on your WorkSpace.
	VolumeEncryptionKey *string `type:"string"`

	// The identifier of the WorkSpace.
	WorkspaceId *string `type:"string"`

	// The properties of the WorkSpace.
	WorkspaceProperties *WorkspaceProperties `type:"structure"`
}

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

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

// Information about a WorkSpace bundle.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspaceBundle
type WorkspaceBundle struct {
	_ struct{} `type:"structure"`

	// The bundle identifier.
	BundleId *string `type:"string"`

	// The compute type. For more information, see Amazon WorkSpaces Bundles (http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles).
	ComputeType *ComputeType `type:"structure"`

	// A description.
	Description *string `type:"string"`

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

	// The owner of the bundle. This is the account identifier of the owner, or
	// AMAZON if the bundle is provided by AWS.
	Owner *string `type:"string"`

	// The size of the root volume.
	RootStorage *RootStorage `type:"structure"`

	// The size of the user storage.
	UserStorage *UserStorage `type:"structure"`
}

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

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

// Describes the connection status of a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspaceConnectionStatus
type WorkspaceConnectionStatus struct {
	_ struct{} `type:"structure"`

	// The connection state of the WorkSpace. The connection state is unknown if
	// the WorkSpace is stopped.
	ConnectionState ConnectionState `type:"string" enum:"true"`

	// The timestamp of the connection state check.
	ConnectionStateCheckTimestamp *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The timestamp of the last known user connection.
	LastKnownUserConnectionTimestamp *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The ID of the WorkSpace.
	WorkspaceId *string `type:"string"`
}

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

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

// Information about an AWS Directory Service directory for use with Amazon
// WorkSpaces.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspaceDirectory
type WorkspaceDirectory struct {
	_ struct{} `type:"structure"`

	// The directory alias.
	Alias *string `type:"string"`

	// The user name for the service account.
	CustomerUserName *string `min:"1" type:"string"`

	// The directory identifier.
	DirectoryId *string `type:"string"`

	// The name of the directory.
	DirectoryName *string `type:"string"`

	// The directory type.
	DirectoryType WorkspaceDirectoryType `type:"string" enum:"true"`

	// The IP addresses of the DNS servers for the directory.
	DnsIpAddresses []string `type:"list"`

	// The identifier of the IAM role. This is the role that allows Amazon WorkSpaces
	// to make calls to other services, such as Amazon EC2, on your behalf.
	IamRoleId *string `type:"string"`

	// The identifiers of the IP access control groups associated with the directory.
	IpGroupIds []string `locationName:"ipGroupIds" type:"list"`

	// The registration code for the directory. This is the code that users enter
	// in their Amazon WorkSpaces client application to connect to the directory.
	RegistrationCode *string `min:"1" type:"string"`

	// The state of the directory's registration with Amazon WorkSpaces
	State WorkspaceDirectoryState `type:"string" enum:"true"`

	// The identifiers of the subnets used with the directory.
	SubnetIds []string `type:"list"`

	// The default creation properties for all WorkSpaces in the directory.
	WorkspaceCreationProperties *DefaultWorkspaceCreationProperties `type:"structure"`

	// The identifier of the security group that is assigned to new WorkSpaces.
	WorkspaceSecurityGroupId *string `type:"string"`
}

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

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

// Information about a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspaceProperties
type WorkspaceProperties struct {
	_ struct{} `type:"structure"`

	// The compute type. For more information, see Amazon WorkSpaces Bundles (http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles).
	ComputeTypeName Compute `type:"string" enum:"true"`

	// The size of the root volume.
	RootVolumeSizeGib *int64 `type:"integer"`

	// The running mode. For more information, see Manage the WorkSpace Running
	// Mode (http://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html).
	RunningMode RunningMode `type:"string" enum:"true"`

	// The time after a user logs off when WorkSpaces are automatically stopped.
	// Configured in 60 minute intervals.
	RunningModeAutoStopTimeoutInMinutes *int64 `type:"integer"`

	// The size of the user storage.
	UserVolumeSizeGib *int64 `type:"integer"`
}

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

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

// Information used to create a WorkSpace.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workspaces-2015-04-08/WorkspaceRequest
type WorkspaceRequest struct {
	_ struct{} `type:"structure"`

	// The identifier of the bundle for the WorkSpace. You can use DescribeWorkspaceBundles
	// to list the available bundles.
	//
	// BundleId is a required field
	BundleId *string `type:"string" required:"true"`

	// The identifier of the AWS Directory Service directory for the WorkSpace.
	// You can use DescribeWorkspaceDirectories to list the available directories.
	//
	// DirectoryId is a required field
	DirectoryId *string `type:"string" required:"true"`

	// Indicates whether the data stored on the root volume is encrypted.
	RootVolumeEncryptionEnabled *bool `type:"boolean"`

	// The tags for the WorkSpace.
	Tags []Tag `type:"list"`

	// The username of the user for the WorkSpace. This username must exist in the
	// AWS Directory Service directory for the WorkSpace.
	//
	// UserName is a required field
	UserName *string `min:"1" type:"string" required:"true"`

	// Indicates whether the data stored on the user volume is encrypted.
	UserVolumeEncryptionEnabled *bool `type:"boolean"`

	// The KMS key used to encrypt data stored on your WorkSpace.
	VolumeEncryptionKey *string `type:"string"`

	// The WorkSpace properties.
	WorkspaceProperties *WorkspaceProperties `type:"structure"`
}

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

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

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

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

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

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

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

type Compute string

// Enum values for Compute
const (
	ComputeValue       Compute = "VALUE"
	ComputeStandard    Compute = "STANDARD"
	ComputePerformance Compute = "PERFORMANCE"
	ComputePower       Compute = "POWER"
	ComputeGraphics    Compute = "GRAPHICS"
)

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

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

type ConnectionState string

// Enum values for ConnectionState
const (
	ConnectionStateConnected    ConnectionState = "CONNECTED"
	ConnectionStateDisconnected ConnectionState = "DISCONNECTED"
	ConnectionStateUnknown      ConnectionState = "UNKNOWN"
)

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

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

type ModificationResourceEnum string

// Enum values for ModificationResourceEnum
const (
	ModificationResourceEnumRootVolume  ModificationResourceEnum = "ROOT_VOLUME"
	ModificationResourceEnumUserVolume  ModificationResourceEnum = "USER_VOLUME"
	ModificationResourceEnumComputeType ModificationResourceEnum = "COMPUTE_TYPE"
)

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

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

type ModificationStateEnum string

// Enum values for ModificationStateEnum
const (
	ModificationStateEnumUpdateInitiated  ModificationStateEnum = "UPDATE_INITIATED"
	ModificationStateEnumUpdateInProgress ModificationStateEnum = "UPDATE_IN_PROGRESS"
)

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

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

type RunningMode string

// Enum values for RunningMode
const (
	RunningModeAutoStop RunningMode = "AUTO_STOP"
	RunningModeAlwaysOn RunningMode = "ALWAYS_ON"
)

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

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

type TargetWorkspaceState string

// Enum values for TargetWorkspaceState
const (
	TargetWorkspaceStateAvailable        TargetWorkspaceState = "AVAILABLE"
	TargetWorkspaceStateAdminMaintenance TargetWorkspaceState = "ADMIN_MAINTENANCE"
)

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

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

type WorkspaceDirectoryState string

// Enum values for WorkspaceDirectoryState
const (
	WorkspaceDirectoryStateRegistering   WorkspaceDirectoryState = "REGISTERING"
	WorkspaceDirectoryStateRegistered    WorkspaceDirectoryState = "REGISTERED"
	WorkspaceDirectoryStateDeregistering WorkspaceDirectoryState = "DEREGISTERING"
	WorkspaceDirectoryStateDeregistered  WorkspaceDirectoryState = "DEREGISTERED"
	WorkspaceDirectoryStateError         WorkspaceDirectoryState = "ERROR"
)

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

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

type WorkspaceDirectoryType string

// Enum values for WorkspaceDirectoryType
const (
	WorkspaceDirectoryTypeSimpleAd    WorkspaceDirectoryType = "SIMPLE_AD"
	WorkspaceDirectoryTypeAdConnector WorkspaceDirectoryType = "AD_CONNECTOR"
)

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

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

type WorkspaceState string

// Enum values for WorkspaceState
const (
	WorkspaceStatePending          WorkspaceState = "PENDING"
	WorkspaceStateAvailable        WorkspaceState = "AVAILABLE"
	WorkspaceStateImpaired         WorkspaceState = "IMPAIRED"
	WorkspaceStateUnhealthy        WorkspaceState = "UNHEALTHY"
	WorkspaceStateRebooting        WorkspaceState = "REBOOTING"
	WorkspaceStateStarting         WorkspaceState = "STARTING"
	WorkspaceStateRebuilding       WorkspaceState = "REBUILDING"
	WorkspaceStateMaintenance      WorkspaceState = "MAINTENANCE"
	WorkspaceStateAdminMaintenance WorkspaceState = "ADMIN_MAINTENANCE"
	WorkspaceStateTerminating      WorkspaceState = "TERMINATING"
	WorkspaceStateTerminated       WorkspaceState = "TERMINATED"
	WorkspaceStateSuspended        WorkspaceState = "SUSPENDED"
	WorkspaceStateUpdating         WorkspaceState = "UPDATING"
	WorkspaceStateStopping         WorkspaceState = "STOPPING"
	WorkspaceStateStopped          WorkspaceState = "STOPPED"
	WorkspaceStateError            WorkspaceState = "ERROR"
)

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

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