api.go

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

package workmail

import (
	"time"

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

const opAssociateDelegateToResource = "AssociateDelegateToResource"

// AssociateDelegateToResourceRequest is a API request type for the AssociateDelegateToResource API operation.
type AssociateDelegateToResourceRequest struct {
	*aws.Request
	Input *AssociateDelegateToResourceInput
	Copy  func(*AssociateDelegateToResourceInput) AssociateDelegateToResourceRequest
}

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

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

// AssociateDelegateToResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Adds a member to the resource's set of delegates.
//
//    // Example sending a request using the AssociateDelegateToResourceRequest method.
//    req := client.AssociateDelegateToResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateDelegateToResource
func (c *WorkMail) AssociateDelegateToResourceRequest(input *AssociateDelegateToResourceInput) AssociateDelegateToResourceRequest {
	op := &aws.Operation{
		Name:       opAssociateDelegateToResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateDelegateToResourceInput{}
	}

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

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

const opAssociateMemberToGroup = "AssociateMemberToGroup"

// AssociateMemberToGroupRequest is a API request type for the AssociateMemberToGroup API operation.
type AssociateMemberToGroupRequest struct {
	*aws.Request
	Input *AssociateMemberToGroupInput
	Copy  func(*AssociateMemberToGroupInput) AssociateMemberToGroupRequest
}

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

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

// AssociateMemberToGroupRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Adds a member to the group's set.
//
//    // Example sending a request using the AssociateMemberToGroupRequest method.
//    req := client.AssociateMemberToGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateMemberToGroup
func (c *WorkMail) AssociateMemberToGroupRequest(input *AssociateMemberToGroupInput) AssociateMemberToGroupRequest {
	op := &aws.Operation{
		Name:       opAssociateMemberToGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateMemberToGroupInput{}
	}

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

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

const opCreateAlias = "CreateAlias"

// CreateAliasRequest is a API request type for the CreateAlias API operation.
type CreateAliasRequest struct {
	*aws.Request
	Input *CreateAliasInput
	Copy  func(*CreateAliasInput) CreateAliasRequest
}

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

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

// CreateAliasRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Adds an alias to the set of a given member of Amazon WorkMail.
//
//    // Example sending a request using the CreateAliasRequest method.
//    req := client.CreateAliasRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateAlias
func (c *WorkMail) CreateAliasRequest(input *CreateAliasInput) CreateAliasRequest {
	op := &aws.Operation{
		Name:       opCreateAlias,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateAliasInput{}
	}

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

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

const opCreateGroup = "CreateGroup"

// CreateGroupRequest is a API request type for the CreateGroup API operation.
type CreateGroupRequest struct {
	*aws.Request
	Input *CreateGroupInput
	Copy  func(*CreateGroupInput) CreateGroupRequest
}

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

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

// CreateGroupRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Creates a group that can be used in Amazon WorkMail by calling the RegisterToWorkMail
// operation.
//
//    // Example sending a request using the CreateGroupRequest method.
//    req := client.CreateGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateGroup
func (c *WorkMail) CreateGroupRequest(input *CreateGroupInput) CreateGroupRequest {
	op := &aws.Operation{
		Name:       opCreateGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateGroupInput{}
	}

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

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

const opCreateResource = "CreateResource"

// CreateResourceRequest is a API request type for the CreateResource API operation.
type CreateResourceRequest struct {
	*aws.Request
	Input *CreateResourceInput
	Copy  func(*CreateResourceInput) CreateResourceRequest
}

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

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

// CreateResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Creates a new Amazon WorkMail resource. The available types are equipment
// and room.
//
//    // Example sending a request using the CreateResourceRequest method.
//    req := client.CreateResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateResource
func (c *WorkMail) CreateResourceRequest(input *CreateResourceInput) CreateResourceRequest {
	op := &aws.Operation{
		Name:       opCreateResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateResourceInput{}
	}

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

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

const opCreateUser = "CreateUser"

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

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

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

// CreateUserRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Creates a user who can be used in Amazon WorkMail by calling the RegisterToWorkMail
// operation.
//
//    // Example sending a request using the CreateUserRequest method.
//    req := client.CreateUserRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateUser
func (c *WorkMail) CreateUserRequest(input *CreateUserInput) CreateUserRequest {
	op := &aws.Operation{
		Name:       opCreateUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

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

const opDeleteAlias = "DeleteAlias"

// DeleteAliasRequest is a API request type for the DeleteAlias API operation.
type DeleteAliasRequest struct {
	*aws.Request
	Input *DeleteAliasInput
	Copy  func(*DeleteAliasInput) DeleteAliasRequest
}

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

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

// DeleteAliasRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Remove the alias from a set of aliases for a given user.
//
//    // Example sending a request using the DeleteAliasRequest method.
//    req := client.DeleteAliasRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteAlias
func (c *WorkMail) DeleteAliasRequest(input *DeleteAliasInput) DeleteAliasRequest {
	op := &aws.Operation{
		Name:       opDeleteAlias,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteAliasInput{}
	}

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

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

const opDeleteGroup = "DeleteGroup"

// DeleteGroupRequest is a API request type for the DeleteGroup API operation.
type DeleteGroupRequest struct {
	*aws.Request
	Input *DeleteGroupInput
	Copy  func(*DeleteGroupInput) DeleteGroupRequest
}

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

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

// DeleteGroupRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Deletes a group from Amazon WorkMail.
//
//    // Example sending a request using the DeleteGroupRequest method.
//    req := client.DeleteGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteGroup
func (c *WorkMail) DeleteGroupRequest(input *DeleteGroupInput) DeleteGroupRequest {
	op := &aws.Operation{
		Name:       opDeleteGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteGroupInput{}
	}

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

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

const opDeleteMailboxPermissions = "DeleteMailboxPermissions"

// DeleteMailboxPermissionsRequest is a API request type for the DeleteMailboxPermissions API operation.
type DeleteMailboxPermissionsRequest struct {
	*aws.Request
	Input *DeleteMailboxPermissionsInput
	Copy  func(*DeleteMailboxPermissionsInput) DeleteMailboxPermissionsRequest
}

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

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

// DeleteMailboxPermissionsRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Deletes permissions granted to a user or group.
//
//    // Example sending a request using the DeleteMailboxPermissionsRequest method.
//    req := client.DeleteMailboxPermissionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteMailboxPermissions
func (c *WorkMail) DeleteMailboxPermissionsRequest(input *DeleteMailboxPermissionsInput) DeleteMailboxPermissionsRequest {
	op := &aws.Operation{
		Name:       opDeleteMailboxPermissions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteMailboxPermissionsInput{}
	}

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

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

const opDeleteResource = "DeleteResource"

// DeleteResourceRequest is a API request type for the DeleteResource API operation.
type DeleteResourceRequest struct {
	*aws.Request
	Input *DeleteResourceInput
	Copy  func(*DeleteResourceInput) DeleteResourceRequest
}

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

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

// DeleteResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Deletes the specified resource.
//
//    // Example sending a request using the DeleteResourceRequest method.
//    req := client.DeleteResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteResource
func (c *WorkMail) DeleteResourceRequest(input *DeleteResourceInput) DeleteResourceRequest {
	op := &aws.Operation{
		Name:       opDeleteResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteResourceInput{}
	}

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

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

const opDeleteUser = "DeleteUser"

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

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

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

// DeleteUserRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Deletes a user from Amazon WorkMail and all subsequent systems. The action
// can't be undone. The mailbox is kept as-is for a minimum of 30 days, without
// any means to restore it.
//
//    // Example sending a request using the DeleteUserRequest method.
//    req := client.DeleteUserRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteUser
func (c *WorkMail) DeleteUserRequest(input *DeleteUserInput) DeleteUserRequest {
	op := &aws.Operation{
		Name:       opDeleteUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

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

const opDeregisterFromWorkMail = "DeregisterFromWorkMail"

// DeregisterFromWorkMailRequest is a API request type for the DeregisterFromWorkMail API operation.
type DeregisterFromWorkMailRequest struct {
	*aws.Request
	Input *DeregisterFromWorkMailInput
	Copy  func(*DeregisterFromWorkMailInput) DeregisterFromWorkMailRequest
}

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

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

// DeregisterFromWorkMailRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Mark a user, group, or resource as no longer used in Amazon WorkMail. This
// action disassociates the mailbox and schedules it for clean-up. Amazon WorkMail
// keeps mailboxes for 30 days before they are permanently removed. The functionality
// in the console is Disable.
//
//    // Example sending a request using the DeregisterFromWorkMailRequest method.
//    req := client.DeregisterFromWorkMailRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeregisterFromWorkMail
func (c *WorkMail) DeregisterFromWorkMailRequest(input *DeregisterFromWorkMailInput) DeregisterFromWorkMailRequest {
	op := &aws.Operation{
		Name:       opDeregisterFromWorkMail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeregisterFromWorkMailInput{}
	}

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

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

const opDescribeGroup = "DescribeGroup"

// DescribeGroupRequest is a API request type for the DescribeGroup API operation.
type DescribeGroupRequest struct {
	*aws.Request
	Input *DescribeGroupInput
	Copy  func(*DescribeGroupInput) DescribeGroupRequest
}

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

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

// DescribeGroupRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns the data available for the group.
//
//    // Example sending a request using the DescribeGroupRequest method.
//    req := client.DescribeGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeGroup
func (c *WorkMail) DescribeGroupRequest(input *DescribeGroupInput) DescribeGroupRequest {
	op := &aws.Operation{
		Name:       opDescribeGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeGroupInput{}
	}

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

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

const opDescribeOrganization = "DescribeOrganization"

// DescribeOrganizationRequest is a API request type for the DescribeOrganization API operation.
type DescribeOrganizationRequest struct {
	*aws.Request
	Input *DescribeOrganizationInput
	Copy  func(*DescribeOrganizationInput) DescribeOrganizationRequest
}

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

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

// DescribeOrganizationRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Provides more information regarding a given organization based on its identifier.
//
//    // Example sending a request using the DescribeOrganizationRequest method.
//    req := client.DescribeOrganizationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeOrganization
func (c *WorkMail) DescribeOrganizationRequest(input *DescribeOrganizationInput) DescribeOrganizationRequest {
	op := &aws.Operation{
		Name:       opDescribeOrganization,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeOrganizationInput{}
	}

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

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

const opDescribeResource = "DescribeResource"

// DescribeResourceRequest is a API request type for the DescribeResource API operation.
type DescribeResourceRequest struct {
	*aws.Request
	Input *DescribeResourceInput
	Copy  func(*DescribeResourceInput) DescribeResourceRequest
}

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

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

// DescribeResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns the data available for the resource.
//
//    // Example sending a request using the DescribeResourceRequest method.
//    req := client.DescribeResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeResource
func (c *WorkMail) DescribeResourceRequest(input *DescribeResourceInput) DescribeResourceRequest {
	op := &aws.Operation{
		Name:       opDescribeResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DescribeResourceInput{}
	}

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

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

const opDescribeUser = "DescribeUser"

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

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

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

// DescribeUserRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Provides information regarding the user.
//
//    // Example sending a request using the DescribeUserRequest method.
//    req := client.DescribeUserRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeUser
func (c *WorkMail) DescribeUserRequest(input *DescribeUserInput) DescribeUserRequest {
	op := &aws.Operation{
		Name:       opDescribeUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

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

const opDisassociateDelegateFromResource = "DisassociateDelegateFromResource"

// DisassociateDelegateFromResourceRequest is a API request type for the DisassociateDelegateFromResource API operation.
type DisassociateDelegateFromResourceRequest struct {
	*aws.Request
	Input *DisassociateDelegateFromResourceInput
	Copy  func(*DisassociateDelegateFromResourceInput) DisassociateDelegateFromResourceRequest
}

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

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

// DisassociateDelegateFromResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Removes a member from the resource's set of delegates.
//
//    // Example sending a request using the DisassociateDelegateFromResourceRequest method.
//    req := client.DisassociateDelegateFromResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateDelegateFromResource
func (c *WorkMail) DisassociateDelegateFromResourceRequest(input *DisassociateDelegateFromResourceInput) DisassociateDelegateFromResourceRequest {
	op := &aws.Operation{
		Name:       opDisassociateDelegateFromResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateDelegateFromResourceInput{}
	}

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

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

const opDisassociateMemberFromGroup = "DisassociateMemberFromGroup"

// DisassociateMemberFromGroupRequest is a API request type for the DisassociateMemberFromGroup API operation.
type DisassociateMemberFromGroupRequest struct {
	*aws.Request
	Input *DisassociateMemberFromGroupInput
	Copy  func(*DisassociateMemberFromGroupInput) DisassociateMemberFromGroupRequest
}

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

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

// DisassociateMemberFromGroupRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Removes a member from a group.
//
//    // Example sending a request using the DisassociateMemberFromGroupRequest method.
//    req := client.DisassociateMemberFromGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateMemberFromGroup
func (c *WorkMail) DisassociateMemberFromGroupRequest(input *DisassociateMemberFromGroupInput) DisassociateMemberFromGroupRequest {
	op := &aws.Operation{
		Name:       opDisassociateMemberFromGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateMemberFromGroupInput{}
	}

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

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

const opListAliases = "ListAliases"

// ListAliasesRequest is a API request type for the ListAliases API operation.
type ListAliasesRequest struct {
	*aws.Request
	Input *ListAliasesInput
	Copy  func(*ListAliasesInput) ListAliasesRequest
}

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

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

// ListAliasesRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Creates a paginated call to list the aliases associated with a given entity.
//
//    // Example sending a request using the ListAliasesRequest method.
//    req := client.ListAliasesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListAliases
func (c *WorkMail) ListAliasesRequest(input *ListAliasesInput) ListAliasesRequest {
	op := &aws.Operation{
		Name:       opListAliases,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListAliasesInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListAliasesRequest 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 ListAliases operation.
//		req := client.ListAliasesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListAliasesRequest) Paginate(opts ...aws.Option) ListAliasesPager {
	return ListAliasesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListAliasesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListAliasesPager) CurrentPage() *ListAliasesOutput {
	return p.Pager.CurrentPage().(*ListAliasesOutput)
}

const opListGroupMembers = "ListGroupMembers"

// ListGroupMembersRequest is a API request type for the ListGroupMembers API operation.
type ListGroupMembersRequest struct {
	*aws.Request
	Input *ListGroupMembersInput
	Copy  func(*ListGroupMembersInput) ListGroupMembersRequest
}

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

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

// ListGroupMembersRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns an overview of the members of a group.
//
//    // Example sending a request using the ListGroupMembersRequest method.
//    req := client.ListGroupMembersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroupMembers
func (c *WorkMail) ListGroupMembersRequest(input *ListGroupMembersInput) ListGroupMembersRequest {
	op := &aws.Operation{
		Name:       opListGroupMembers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListGroupMembersInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListGroupMembersRequest 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 ListGroupMembers operation.
//		req := client.ListGroupMembersRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListGroupMembersRequest) Paginate(opts ...aws.Option) ListGroupMembersPager {
	return ListGroupMembersPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListGroupMembersInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListGroupMembersPager) CurrentPage() *ListGroupMembersOutput {
	return p.Pager.CurrentPage().(*ListGroupMembersOutput)
}

const opListGroups = "ListGroups"

// ListGroupsRequest is a API request type for the ListGroups API operation.
type ListGroupsRequest struct {
	*aws.Request
	Input *ListGroupsInput
	Copy  func(*ListGroupsInput) ListGroupsRequest
}

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

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

// ListGroupsRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns summaries of the organization's groups.
//
//    // Example sending a request using the ListGroupsRequest method.
//    req := client.ListGroupsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroups
func (c *WorkMail) ListGroupsRequest(input *ListGroupsInput) ListGroupsRequest {
	op := &aws.Operation{
		Name:       opListGroups,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListGroupsInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListGroupsRequest 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 ListGroups operation.
//		req := client.ListGroupsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListGroupsRequest) Paginate(opts ...aws.Option) ListGroupsPager {
	return ListGroupsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListGroupsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListGroupsPager) CurrentPage() *ListGroupsOutput {
	return p.Pager.CurrentPage().(*ListGroupsOutput)
}

const opListMailboxPermissions = "ListMailboxPermissions"

// ListMailboxPermissionsRequest is a API request type for the ListMailboxPermissions API operation.
type ListMailboxPermissionsRequest struct {
	*aws.Request
	Input *ListMailboxPermissionsInput
	Copy  func(*ListMailboxPermissionsInput) ListMailboxPermissionsRequest
}

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

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

// ListMailboxPermissionsRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Lists the mailbox permissions associated with a mailbox.
//
//    // Example sending a request using the ListMailboxPermissionsRequest method.
//    req := client.ListMailboxPermissionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListMailboxPermissions
func (c *WorkMail) ListMailboxPermissionsRequest(input *ListMailboxPermissionsInput) ListMailboxPermissionsRequest {
	op := &aws.Operation{
		Name:       opListMailboxPermissions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListMailboxPermissionsInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListMailboxPermissionsRequest 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 ListMailboxPermissions operation.
//		req := client.ListMailboxPermissionsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListMailboxPermissionsRequest) Paginate(opts ...aws.Option) ListMailboxPermissionsPager {
	return ListMailboxPermissionsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListMailboxPermissionsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListMailboxPermissionsPager) CurrentPage() *ListMailboxPermissionsOutput {
	return p.Pager.CurrentPage().(*ListMailboxPermissionsOutput)
}

const opListOrganizations = "ListOrganizations"

// ListOrganizationsRequest is a API request type for the ListOrganizations API operation.
type ListOrganizationsRequest struct {
	*aws.Request
	Input *ListOrganizationsInput
	Copy  func(*ListOrganizationsInput) ListOrganizationsRequest
}

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

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

// ListOrganizationsRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns summaries of the customer's non-deleted organizations.
//
//    // Example sending a request using the ListOrganizationsRequest method.
//    req := client.ListOrganizationsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListOrganizations
func (c *WorkMail) ListOrganizationsRequest(input *ListOrganizationsInput) ListOrganizationsRequest {
	op := &aws.Operation{
		Name:       opListOrganizations,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListOrganizationsInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListOrganizationsRequest 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 ListOrganizations operation.
//		req := client.ListOrganizationsRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListOrganizationsRequest) Paginate(opts ...aws.Option) ListOrganizationsPager {
	return ListOrganizationsPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListOrganizationsInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListOrganizationsPager) CurrentPage() *ListOrganizationsOutput {
	return p.Pager.CurrentPage().(*ListOrganizationsOutput)
}

const opListResourceDelegates = "ListResourceDelegates"

// ListResourceDelegatesRequest is a API request type for the ListResourceDelegates API operation.
type ListResourceDelegatesRequest struct {
	*aws.Request
	Input *ListResourceDelegatesInput
	Copy  func(*ListResourceDelegatesInput) ListResourceDelegatesRequest
}

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

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

// ListResourceDelegatesRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Lists the delegates associated with a resource. Users and groups can be resource
// delegates and answer requests on behalf of the resource.
//
//    // Example sending a request using the ListResourceDelegatesRequest method.
//    req := client.ListResourceDelegatesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResourceDelegates
func (c *WorkMail) ListResourceDelegatesRequest(input *ListResourceDelegatesInput) ListResourceDelegatesRequest {
	op := &aws.Operation{
		Name:       opListResourceDelegates,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListResourceDelegatesInput{}
	}

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

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

const opListResources = "ListResources"

// ListResourcesRequest is a API request type for the ListResources API operation.
type ListResourcesRequest struct {
	*aws.Request
	Input *ListResourcesInput
	Copy  func(*ListResourcesInput) ListResourcesRequest
}

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

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

// ListResourcesRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns summaries of the organization's resources.
//
//    // Example sending a request using the ListResourcesRequest method.
//    req := client.ListResourcesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResources
func (c *WorkMail) ListResourcesRequest(input *ListResourcesInput) ListResourcesRequest {
	op := &aws.Operation{
		Name:       opListResources,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListResourcesInput{}
	}

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

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

// Paginate pages iterates over the pages of a ListResourcesRequest 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 ListResources operation.
//		req := client.ListResourcesRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListResourcesRequest) Paginate(opts ...aws.Option) ListResourcesPager {
	return ListResourcesPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListResourcesInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListResourcesPager) CurrentPage() *ListResourcesOutput {
	return p.Pager.CurrentPage().(*ListResourcesOutput)
}

const opListUsers = "ListUsers"

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

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

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

// ListUsersRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Returns summaries of the organization's users.
//
//    // Example sending a request using the ListUsersRequest method.
//    req := client.ListUsersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListUsers
func (c *WorkMail) ListUsersRequest(input *ListUsersInput) ListUsersRequest {
	op := &aws.Operation{
		Name:       opListUsers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

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

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

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

// Paginate pages iterates over the pages of a ListUsersRequest 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 ListUsers operation.
//		req := client.ListUsersRequest(input)
//		p := req.Paginate()
//		for p.Next() {
//			page := p.CurrentPage()
//		}
//
//		if err := p.Err(); err != nil {
//			return err
//		}
//
func (p *ListUsersRequest) Paginate(opts ...aws.Option) ListUsersPager {
	return ListUsersPager{
		Pager: aws.Pager{
			NewRequest: func() (*aws.Request, error) {
				var inCpy *ListUsersInput
				if p.Input != nil {
					tmp := *p.Input
					inCpy = &tmp
				}

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

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

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

func (p *ListUsersPager) CurrentPage() *ListUsersOutput {
	return p.Pager.CurrentPage().(*ListUsersOutput)
}

const opPutMailboxPermissions = "PutMailboxPermissions"

// PutMailboxPermissionsRequest is a API request type for the PutMailboxPermissions API operation.
type PutMailboxPermissionsRequest struct {
	*aws.Request
	Input *PutMailboxPermissionsInput
	Copy  func(*PutMailboxPermissionsInput) PutMailboxPermissionsRequest
}

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

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

// PutMailboxPermissionsRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Sets permissions for a user or group. This replaces any pre-existing permissions
// set for the entity.
//
//    // Example sending a request using the PutMailboxPermissionsRequest method.
//    req := client.PutMailboxPermissionsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/PutMailboxPermissions
func (c *WorkMail) PutMailboxPermissionsRequest(input *PutMailboxPermissionsInput) PutMailboxPermissionsRequest {
	op := &aws.Operation{
		Name:       opPutMailboxPermissions,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &PutMailboxPermissionsInput{}
	}

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

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

const opRegisterToWorkMail = "RegisterToWorkMail"

// RegisterToWorkMailRequest is a API request type for the RegisterToWorkMail API operation.
type RegisterToWorkMailRequest struct {
	*aws.Request
	Input *RegisterToWorkMailInput
	Copy  func(*RegisterToWorkMailInput) RegisterToWorkMailRequest
}

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

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

// RegisterToWorkMailRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Registers an existing and disabled user, group, or resource/entity for Amazon
// WorkMail use by associating a mailbox and calendaring capabilities. It performs
// no change if the entity is enabled and fails if the entity is deleted. This
// operation results in the accumulation of costs. For more information, see
// Pricing (http://aws.amazon.com/workmail/pricing). The equivalent console
// functionality for this operation is Enable. Users can either be created by
// calling the CreateUser API or they can be synchronized from your directory.
// For more information, see DeregisterFromWorkMail.
//
//    // Example sending a request using the RegisterToWorkMailRequest method.
//    req := client.RegisterToWorkMailRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/RegisterToWorkMail
func (c *WorkMail) RegisterToWorkMailRequest(input *RegisterToWorkMailInput) RegisterToWorkMailRequest {
	op := &aws.Operation{
		Name:       opRegisterToWorkMail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RegisterToWorkMailInput{}
	}

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

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

const opResetPassword = "ResetPassword"

// ResetPasswordRequest is a API request type for the ResetPassword API operation.
type ResetPasswordRequest struct {
	*aws.Request
	Input *ResetPasswordInput
	Copy  func(*ResetPasswordInput) ResetPasswordRequest
}

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

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

// ResetPasswordRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Allows the administrator to reset the password for a user.
//
//    // Example sending a request using the ResetPasswordRequest method.
//    req := client.ResetPasswordRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ResetPassword
func (c *WorkMail) ResetPasswordRequest(input *ResetPasswordInput) ResetPasswordRequest {
	op := &aws.Operation{
		Name:       opResetPassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ResetPasswordInput{}
	}

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

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

const opUpdatePrimaryEmailAddress = "UpdatePrimaryEmailAddress"

// UpdatePrimaryEmailAddressRequest is a API request type for the UpdatePrimaryEmailAddress API operation.
type UpdatePrimaryEmailAddressRequest struct {
	*aws.Request
	Input *UpdatePrimaryEmailAddressInput
	Copy  func(*UpdatePrimaryEmailAddressInput) UpdatePrimaryEmailAddressRequest
}

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

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

// UpdatePrimaryEmailAddressRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Updates the primary email for an entity. The current email is moved into
// the list of aliases (or swapped between an existing alias and the current
// primary email) and the email provided in the input is promoted as the primary.
//
//    // Example sending a request using the UpdatePrimaryEmailAddressRequest method.
//    req := client.UpdatePrimaryEmailAddressRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdatePrimaryEmailAddress
func (c *WorkMail) UpdatePrimaryEmailAddressRequest(input *UpdatePrimaryEmailAddressInput) UpdatePrimaryEmailAddressRequest {
	op := &aws.Operation{
		Name:       opUpdatePrimaryEmailAddress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdatePrimaryEmailAddressInput{}
	}

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

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

const opUpdateResource = "UpdateResource"

// UpdateResourceRequest is a API request type for the UpdateResource API operation.
type UpdateResourceRequest struct {
	*aws.Request
	Input *UpdateResourceInput
	Copy  func(*UpdateResourceInput) UpdateResourceRequest
}

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

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

// UpdateResourceRequest returns a request value for making API operation for
// Amazon WorkMail.
//
// Updates data for the resource. It must be preceded by a describe call in
// order to have the latest information. The dataset in the request should be
// the one expected when performing another describe call.
//
//    // Example sending a request using the UpdateResourceRequest method.
//    req := client.UpdateResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdateResource
func (c *WorkMail) UpdateResourceRequest(input *UpdateResourceInput) UpdateResourceRequest {
	op := &aws.Operation{
		Name:       opUpdateResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateResourceInput{}
	}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateDelegateToResourceRequest
type AssociateDelegateToResourceInput struct {
	_ struct{} `type:"structure"`

	// The member (user or group) to associate to the resource.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The organization under which the resource exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The resource for which members are associated.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateDelegateToResourceResponse
type AssociateDelegateToResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateMemberToGroupRequest
type AssociateMemberToGroupInput struct {
	_ struct{} `type:"structure"`

	// The group for which the member is associated.
	//
	// GroupId is a required field
	GroupId *string `min:"12" type:"string" required:"true"`

	// The member to associate to the group.
	//
	// MemberId is a required field
	MemberId *string `min:"12" type:"string" required:"true"`

	// The organization under which the group exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/AssociateMemberToGroupResponse
type AssociateMemberToGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// At least one delegate must be associated to the resource to disable automatic
// replies from the resource.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/BookingOptions
type BookingOptions struct {
	_ struct{} `type:"structure"`

	// The resource's ability to automatically reply to requests. If disabled, delegates
	// must be associated to the resource.
	AutoAcceptRequests *bool `type:"boolean"`

	// The resource's ability to automatically decline any conflicting requests.
	AutoDeclineConflictingRequests *bool `type:"boolean"`

	// The resource's ability to automatically decline any recurring requests.
	AutoDeclineRecurringRequests *bool `type:"boolean"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateAliasRequest
type CreateAliasInput struct {
	_ struct{} `type:"structure"`

	// The alias to add to the user.
	//
	// Alias is a required field
	Alias *string `min:"1" type:"string" required:"true"`

	// The alias is added to this Amazon WorkMail entity.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The organization under which the member exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateAliasResponse
type CreateAliasOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateGroupRequest
type CreateGroupInput struct {
	_ struct{} `type:"structure"`

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

	// The organization under which the group is to be created.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateGroupResponse
type CreateGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateResourceRequest
type CreateResourceInput struct {
	_ struct{} `type:"structure"`

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

	// The identifier associated with the organization for which the resource is
	// created.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The type of the created resource.
	//
	// Type is a required field
	Type ResourceType `type:"string" required:"true" enum:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateResourceResponse
type CreateResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The identifier of the created resource.
	ResourceId *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateUserRequest
type CreateUserInput struct {
	_ struct{} `type:"structure"`

	// The display name for the user to be created.
	//
	// DisplayName is a required field
	DisplayName *string `type:"string" required:"true"`

	// The name for the user to be created.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The identifier of the organization for which the user is created.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The password for the user to be created.
	//
	// Password is a required field
	Password *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/CreateUserResponse
type CreateUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The information regarding the newly created user.
	UserId *string `min:"12" type:"string"`
}

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

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

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

// The name of the attribute, which is one of the values defined in the UserAttribute
// enumeration.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/Delegate
type Delegate struct {
	_ struct{} `type:"structure"`

	// The identifier for the user or group is associated as the resource's delegate.
	//
	// Id is a required field
	Id *string `type:"string" required:"true"`

	// The type of the delegate: user or group.
	//
	// Type is a required field
	Type MemberType `type:"string" required:"true" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteAliasRequest
type DeleteAliasInput struct {
	_ struct{} `type:"structure"`

	// The aliases to be removed from the user's set of aliases. Duplicate entries
	// in the list are collapsed into single entries (the list is transformed into
	// a set).
	//
	// Alias is a required field
	Alias *string `min:"1" type:"string" required:"true"`

	// The identifier for the Amazon WorkMail entity to have the aliases removed.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the user exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteAliasResponse
type DeleteAliasOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteGroupRequest
type DeleteGroupInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the group to be deleted.
	//
	// GroupId is a required field
	GroupId *string `min:"12" type:"string" required:"true"`

	// The organization that contains the group.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteGroupResponse
type DeleteGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteMailboxPermissionsRequest
type DeleteMailboxPermissionsInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the entity (user or group) for which to delete mailbox
	// permissions.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier of the entity (user or group) for which to delete granted
	// permissions.
	//
	// GranteeId is a required field
	GranteeId *string `min:"12" type:"string" required:"true"`

	// The identifier of the organization under which the entity (user or group)
	// exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteMailboxPermissionsResponse
type DeleteMailboxPermissionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteResourceRequest
type DeleteResourceInput struct {
	_ struct{} `type:"structure"`

	// The identifier associated with the organization for which the resource is
	// deleted.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier of the resource to be deleted.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteResourceResponse
type DeleteResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteUserRequest
type DeleteUserInput struct {
	_ struct{} `type:"structure"`

	// The organization that contains the user.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier of the user to be deleted.
	//
	// UserId is a required field
	UserId *string `min:"12" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeleteUserResponse
type DeleteUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeregisterFromWorkMailRequest
type DeregisterFromWorkMailInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the entity to be updated.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the Amazon WorkMail entity
	// exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DeregisterFromWorkMailResponse
type DeregisterFromWorkMailOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeGroupRequest
type DescribeGroupInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the group to be described.
	//
	// GroupId is a required field
	GroupId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the group exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeGroupResponse
type DescribeGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The date and time when a user was deregistered from Amazon WorkMail, in UNIX
	// epoch time format.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The email of the described group.
	Email *string `min:"1" type:"string"`

	// The date and time when a user was registered to Amazon WorkMail, in UNIX
	// epoch time format.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the described group.
	GroupId *string `min:"12" type:"string"`

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

	// The state of the user: enabled (registered to Amazon WorkMail) or disabled
	// (deregistered or never registered to Amazon WorkMail).
	State EntityState `type:"string" enum:"true"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeOrganizationRequest
type DescribeOrganizationInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the organization to be described.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeOrganizationResponse
type DescribeOrganizationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The alias for an organization.
	Alias *string `min:"1" type:"string"`

	// The date at which the organization became usable in the Amazon WorkMail context,
	// in UNIX epoch time format.
	CompletedDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The default mail domain associated with the organization.
	DefaultMailDomain *string `type:"string"`

	// The identifier for the directory associated with an Amazon WorkMail organization.
	DirectoryId *string `type:"string"`

	// The type of directory associated with the Amazon WorkMail organization.
	DirectoryType *string `type:"string"`

	// The (optional) error message indicating if unexpected behavior was encountered
	// with regards to the organization.
	ErrorMessage *string `type:"string"`

	// The identifier of an organization.
	OrganizationId *string `type:"string"`

	// The state of an organization.
	State *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeResourceRequest
type DescribeResourceInput struct {
	_ struct{} `type:"structure"`

	// The identifier associated with the organization for which the resource is
	// described.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier of the resource to be described.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeResourceResponse
type DescribeResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The booking options for the described resource.
	BookingOptions *BookingOptions `type:"structure"`

	// The date and time when a resource was registered from Amazon WorkMail, in
	// UNIX epoch time format.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The email of the described resource.
	Email *string `min:"1" type:"string"`

	// The date and time when a resource was registered to Amazon WorkMail, in UNIX
	// epoch time format.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

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

	// The identifier of the described resource.
	ResourceId *string `type:"string"`

	// The state of the resource: enabled (registered to Amazon WorkMail) or disabled
	// (deregistered or never registered to Amazon WorkMail).
	State EntityState `type:"string" enum:"true"`

	// The type of the described resource.
	Type ResourceType `type:"string" enum:"true"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeUserRequest
type DescribeUserInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the organization under which the user exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier for the user to be described.
	//
	// UserId is a required field
	UserId *string `min:"12" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DescribeUserResponse
type DescribeUserOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The date and time at which the user was disabled for Amazon WorkMail usage,
	// in UNIX epoch time format.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The display name of the user.
	DisplayName *string `type:"string"`

	// The email of the user.
	Email *string `min:"1" type:"string"`

	// The date and time at which the user was enabled for Amazon WorkMail usage,
	// in UNIX epoch time format.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The name for the user.
	Name *string `min:"1" type:"string"`

	// The state of a user: enabled (registered to Amazon WorkMail) or disabled
	// (deregistered or never registered to Amazon WorkMail).
	State EntityState `type:"string" enum:"true"`

	// The identifier for the described user.
	UserId *string `min:"12" type:"string"`

	// In certain cases other entities are modeled as users. If interoperability
	// is enabled, resources are imported into Amazon WorkMail as users. Because
	// different Amazon WorkMail organizations rely on different directory types,
	// administrators can distinguish between a user that is not registered to Amazon
	// WorkMail (is disabled and has a user role) and the administrative users of
	// the directory. The values are USER, RESOURCE, and SYSTEM_USER.
	UserRole UserRole `type:"string" enum:"true"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateDelegateFromResourceRequest
type DisassociateDelegateFromResourceInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the member (user, group) to be removed from the resource's
	// delegates.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the resource exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier of the resource from which delegates' set members are removed.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateDelegateFromResourceResponse
type DisassociateDelegateFromResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateMemberFromGroupRequest
type DisassociateMemberFromGroupInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the group from which members are removed.
	//
	// GroupId is a required field
	GroupId *string `min:"12" type:"string" required:"true"`

	// The identifier for the member to be removed to the group.
	//
	// MemberId is a required field
	MemberId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the group exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/DisassociateMemberFromGroupResponse
type DisassociateMemberFromGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// The representation of an Amazon WorkMail group.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/Group
type Group struct {
	_ struct{} `type:"structure"`

	// The date indicating when the group was disabled from Amazon WorkMail use.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The email of the group.
	Email *string `min:"1" type:"string"`

	// The date indicating when the group was enabled for Amazon WorkMail use.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the group.
	Id *string `min:"12" type:"string"`

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

	// The state of the group, which can be ENABLED, DISABLED, or DELETED.
	State EntityState `type:"string" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListAliasesRequest
type ListAliasesInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the entity for which to list the aliases.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization under which the entity exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListAliasesResponse
type ListAliasesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The entity's paginated aliases.
	Aliases []string `type:"list"`

	// The token to use to retrieve the next page of results. The value is "null"
	// when there are no more results to return.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroupMembersRequest
type ListGroupMembersInput struct {
	_ struct{} `type:"structure"`

	// The identifier for the group to which the members are associated.
	//
	// GroupId is a required field
	GroupId *string `min:"12" type:"string" required:"true"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization under which the group exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroupMembersResponse
type ListGroupMembersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The members associated to the group.
	Members []Member `type:"list"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroupsRequest
type ListGroupsInput struct {
	_ struct{} `type:"structure"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization under which the groups exist.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListGroupsResponse
type ListGroupsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The overview of groups for an organization.
	Groups []Group `type:"list"`

	// The token to use to retrieve the next page of results. The value is "null"
	// when there are no more results to return.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListMailboxPermissionsRequest
type ListMailboxPermissionsInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the entity (user or group) for which to list mailbox permissions.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`

	// The identifier of the organization under which the entity (user or group)
	// exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListMailboxPermissionsResponse
type ListMailboxPermissionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next page of results. The value is "null"
	// when there are no more results to return.
	NextToken *string `min:"1" type:"string"`

	// One page of the entity's mailbox permissions.
	Permissions []Permission `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListOrganizationsRequest
type ListOrganizationsInput struct {
	_ struct{} `type:"structure"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListOrganizationsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListOrganizationsInput"}
	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/workmail-2017-10-01/ListOrganizationsResponse
type ListOrganizationsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next page of results. The value is "null"
	// when there are no more results to return.
	NextToken *string `min:"1" type:"string"`

	// The overview of owned organizations presented as a list of organization summaries.
	OrganizationSummaries []OrganizationSummary `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResourceDelegatesRequest
type ListResourceDelegatesInput struct {
	_ struct{} `type:"structure"`

	// The number of maximum results in a page.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token used to paginate through the delegates associated with a resource.
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization that contains the resource for which
	// delegates are listed.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier for the resource whose delegates are listed.
	//
	// ResourceId is a required field
	ResourceId *string `min:"12" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResourceDelegatesResponse
type ListResourceDelegatesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// One page of the resource's delegates.
	Delegates []Delegate `type:"list"`

	// The token used to paginate through the delegates associated with a resource.
	// While results are still available, it has an associated value. When the last
	// page is reached, the token is empty.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResourcesRequest
type ListResourcesInput struct {
	_ struct{} `type:"structure"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// The token to use to retrieve the next page of results. The first call does
	// not contain any tokens.
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization under which the resources exist.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListResourcesResponse
type ListResourcesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token used to paginate through all the organization's resources. While
	// results are still available, it has an associated value. When the last page
	// is reached, the token is empty.
	NextToken *string `min:"1" type:"string"`

	// One page of the organization's resource representation.
	Resources []Resource `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListUsersRequest
type ListUsersInput struct {
	_ struct{} `type:"structure"`

	// The maximum number of results to return in a single call.
	MaxResults *int64 `min:"1" type:"integer"`

	// TBD
	NextToken *string `min:"1" type:"string"`

	// The identifier for the organization under which the users exist.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ListUsersResponse
type ListUsersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token to use to retrieve the next page of results. This value is `null`
	// when there are no more results to return.
	NextToken *string `min:"1" type:"string"`

	// The overview of users for an organization.
	Users []User `type:"list"`
}

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

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

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

// The representation of a group member (user or group).
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/Member
type Member struct {
	_ struct{} `type:"structure"`

	// The date indicating when the member was disabled from Amazon WorkMail use.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The date indicating when the member was enabled for Amazon WorkMail use.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the member.
	Id *string `type:"string"`

	// The name of the member.
	Name *string `type:"string"`

	// The state of the member, which can be ENABLED, DISABLED, or DELETED.
	State EntityState `type:"string" enum:"true"`

	// A member can be a user or group.
	Type MemberType `type:"string" enum:"true"`
}

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

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

// The brief overview associated with an organization.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/OrganizationSummary
type OrganizationSummary struct {
	_ struct{} `type:"structure"`

	// The alias associated with the organization.
	Alias *string `min:"1" type:"string"`

	// The error message associated with the organization. It is only present if
	// unexpected behavior has occurred with regards to the organization. It provides
	// insight or solutions regarding unexpected behavior.
	ErrorMessage *string `type:"string"`

	// The identifier associated with the organization.
	OrganizationId *string `type:"string"`

	// The state associated with the organization.
	State *string `type:"string"`
}

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

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

// Permission granted to an entity (user, group) to access a certain aspect
// of another entity's mailbox.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/Permission
type Permission struct {
	_ struct{} `type:"structure"`

	// The identifier of the entity (user or group) to which the permissions are
	// granted.
	//
	// GranteeId is a required field
	GranteeId *string `min:"12" type:"string" required:"true"`

	// The type of entity (user, group) of the entity referred to in GranteeId.
	//
	// GranteeType is a required field
	GranteeType MemberType `type:"string" required:"true" enum:"true"`

	// The permissions granted to the grantee. SEND_AS allows the grantee to send
	// email as the owner of the mailbox (the grantee is not mentioned on these
	// emails). SEND_ON_BEHALF allows the grantee to send email on behalf of the
	// owner of the mailbox (the grantee is not mentioned as the physical sender
	// of these emails). FULL_ACCESS allows the grantee full access to the mailbox,
	// irrespective of other folder-level permissions set on the mailbox.
	//
	// PermissionValues is a required field
	PermissionValues []PermissionType `type:"list" required:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/PutMailboxPermissionsRequest
type PutMailboxPermissionsInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the entity (user or group) for which to update mailbox
	// permissions.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier of the entity (user or group) to which to grant the permissions.
	//
	// GranteeId is a required field
	GranteeId *string `min:"12" type:"string" required:"true"`

	// The identifier of the organization under which the entity (user or group)
	// exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The permissions granted to the grantee. SEND_AS allows the grantee to send
	// email as the owner of the mailbox (the grantee is not mentioned on these
	// emails). SEND_ON_BEHALF allows the grantee to send email on behalf of the
	// owner of the mailbox (the grantee is not mentioned as the physical sender
	// of these emails). FULL_ACCESS allows the grantee full access to the mailbox,
	// irrespective of other folder-level permissions set on the mailbox.
	//
	// PermissionValues is a required field
	PermissionValues []PermissionType `type:"list" required:"true"`
}

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

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/PutMailboxPermissionsResponse
type PutMailboxPermissionsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/RegisterToWorkMailRequest
type RegisterToWorkMailInput struct {
	_ struct{} `type:"structure"`

	// The email for the entity to be updated.
	//
	// Email is a required field
	Email *string `min:"1" type:"string" required:"true"`

	// The identifier for the entity to be updated.
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The identifier for the organization under which the Amazon WorkMail entity
	// exists.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/RegisterToWorkMailResponse
type RegisterToWorkMailOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ResetPasswordRequest
type ResetPasswordInput struct {
	_ struct{} `type:"structure"`

	// The identifier of the organization that contains the user for which the password
	// is reset.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The new password for the user.
	//
	// Password is a required field
	Password *string `type:"string" required:"true"`

	// The identifier of the user for whom the password is reset.
	//
	// UserId is a required field
	UserId *string `min:"12" type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/ResetPasswordResponse
type ResetPasswordOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// The overview for a resource containing relevant data regarding it.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/Resource
type Resource struct {
	_ struct{} `type:"structure"`

	// The date indicating when the resource was disabled from Amazon WorkMail use.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The email of the resource.
	Email *string `min:"1" type:"string"`

	// The date indicating when the resource was enabled for Amazon WorkMail use.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the resource.
	Id *string `min:"12" type:"string"`

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

	// The state of the resource, which can be ENABLED, DISABLED, or DELETED.
	State EntityState `type:"string" enum:"true"`

	// The type of the resource: equipment or room.
	Type ResourceType `type:"string" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdatePrimaryEmailAddressRequest
type UpdatePrimaryEmailAddressInput struct {
	_ struct{} `type:"structure"`

	// The value of the email to be updated as primary.
	//
	// Email is a required field
	Email *string `min:"1" type:"string" required:"true"`

	// The entity to update (user, group, or resource).
	//
	// EntityId is a required field
	EntityId *string `min:"12" type:"string" required:"true"`

	// The organization that contains the entity to update.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdatePrimaryEmailAddressResponse
type UpdatePrimaryEmailAddressOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdateResourceRequest
type UpdateResourceInput struct {
	_ struct{} `type:"structure"`

	// The resource's booking options to be updated.
	BookingOptions *BookingOptions `type:"structure"`

	// The name of the resource to be updated.
	Name *string `min:"1" type:"string"`

	// The identifier associated with the organization for which the resource is
	// updated.
	//
	// OrganizationId is a required field
	OrganizationId *string `type:"string" required:"true"`

	// The identifier of the resource to be updated.
	//
	// ResourceId is a required field
	ResourceId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/UpdateResourceResponse
type UpdateResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// The representation of an Amazon WorkMail user.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/workmail-2017-10-01/User
type User struct {
	_ struct{} `type:"structure"`

	// The date indicating when the user was disabled from Amazon WorkMail use.
	DisabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The display name of the user.
	DisplayName *string `type:"string"`

	// The email of the user.
	Email *string `min:"1" type:"string"`

	// The date indicating when the user was enabled for Amazon WorkMail use.
	EnabledDate *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The identifier of the user.
	Id *string `min:"12" type:"string"`

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

	// The state of the user, which can be ENABLED, DISABLED, or DELETED.
	State EntityState `type:"string" enum:"true"`

	// The role of the user.
	UserRole UserRole `type:"string" enum:"true"`
}

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

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

type EntityState string

// Enum values for EntityState
const (
	EntityStateEnabled  EntityState = "ENABLED"
	EntityStateDisabled EntityState = "DISABLED"
	EntityStateDeleted  EntityState = "DELETED"
)

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

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

type MemberType string

// Enum values for MemberType
const (
	MemberTypeGroup MemberType = "GROUP"
	MemberTypeUser  MemberType = "USER"
)

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

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

type PermissionType string

// Enum values for PermissionType
const (
	PermissionTypeFullAccess   PermissionType = "FULL_ACCESS"
	PermissionTypeSendAs       PermissionType = "SEND_AS"
	PermissionTypeSendOnBehalf PermissionType = "SEND_ON_BEHALF"
)

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

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

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeRoom      ResourceType = "ROOM"
	ResourceTypeEquipment ResourceType = "EQUIPMENT"
)

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

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

type UserRole string

// Enum values for UserRole
const (
	UserRoleUser       UserRole = "USER"
	UserRoleResource   UserRole = "RESOURCE"
	UserRoleSystemUser UserRole = "SYSTEM_USER"
)

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

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