api.go

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

package alexaforbusiness

import (
	"fmt"
	"time"

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

const opAssociateContactWithAddressBook = "AssociateContactWithAddressBook"

// AssociateContactWithAddressBookRequest is a API request type for the AssociateContactWithAddressBook API operation.
type AssociateContactWithAddressBookRequest struct {
	*aws.Request
	Input *AssociateContactWithAddressBookInput
	Copy  func(*AssociateContactWithAddressBookInput) AssociateContactWithAddressBookRequest
}

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

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

// AssociateContactWithAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Associates a contact with a given address book.
//
//    // Example sending a request using the AssociateContactWithAddressBookRequest method.
//    req := client.AssociateContactWithAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateContactWithAddressBook
func (c *AlexaForBusiness) AssociateContactWithAddressBookRequest(input *AssociateContactWithAddressBookInput) AssociateContactWithAddressBookRequest {
	op := &aws.Operation{
		Name:       opAssociateContactWithAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateContactWithAddressBookInput{}
	}

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

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

const opAssociateDeviceWithRoom = "AssociateDeviceWithRoom"

// AssociateDeviceWithRoomRequest is a API request type for the AssociateDeviceWithRoom API operation.
type AssociateDeviceWithRoomRequest struct {
	*aws.Request
	Input *AssociateDeviceWithRoomInput
	Copy  func(*AssociateDeviceWithRoomInput) AssociateDeviceWithRoomRequest
}

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

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

// AssociateDeviceWithRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Associates a device with a given room. This applies all the settings from
// the room profile to the device, and all the skills in any skill groups added
// to that room. This operation requires the device to be online, or else a
// manual sync is required.
//
//    // Example sending a request using the AssociateDeviceWithRoomRequest method.
//    req := client.AssociateDeviceWithRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateDeviceWithRoom
func (c *AlexaForBusiness) AssociateDeviceWithRoomRequest(input *AssociateDeviceWithRoomInput) AssociateDeviceWithRoomRequest {
	op := &aws.Operation{
		Name:       opAssociateDeviceWithRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateDeviceWithRoomInput{}
	}

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

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

const opAssociateSkillGroupWithRoom = "AssociateSkillGroupWithRoom"

// AssociateSkillGroupWithRoomRequest is a API request type for the AssociateSkillGroupWithRoom API operation.
type AssociateSkillGroupWithRoomRequest struct {
	*aws.Request
	Input *AssociateSkillGroupWithRoomInput
	Copy  func(*AssociateSkillGroupWithRoomInput) AssociateSkillGroupWithRoomRequest
}

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

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

// AssociateSkillGroupWithRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Associates a skill group with a given room. This enables all skills in the
// associated skill group on all devices in the room.
//
//    // Example sending a request using the AssociateSkillGroupWithRoomRequest method.
//    req := client.AssociateSkillGroupWithRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateSkillGroupWithRoom
func (c *AlexaForBusiness) AssociateSkillGroupWithRoomRequest(input *AssociateSkillGroupWithRoomInput) AssociateSkillGroupWithRoomRequest {
	op := &aws.Operation{
		Name:       opAssociateSkillGroupWithRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AssociateSkillGroupWithRoomInput{}
	}

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

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

const opCreateAddressBook = "CreateAddressBook"

// CreateAddressBookRequest is a API request type for the CreateAddressBook API operation.
type CreateAddressBookRequest struct {
	*aws.Request
	Input *CreateAddressBookInput
	Copy  func(*CreateAddressBookInput) CreateAddressBookRequest
}

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

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

// CreateAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Creates an address book with the specified details.
//
//    // Example sending a request using the CreateAddressBookRequest method.
//    req := client.CreateAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateAddressBook
func (c *AlexaForBusiness) CreateAddressBookRequest(input *CreateAddressBookInput) CreateAddressBookRequest {
	op := &aws.Operation{
		Name:       opCreateAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateAddressBookInput{}
	}

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

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

const opCreateContact = "CreateContact"

// CreateContactRequest is a API request type for the CreateContact API operation.
type CreateContactRequest struct {
	*aws.Request
	Input *CreateContactInput
	Copy  func(*CreateContactInput) CreateContactRequest
}

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

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

// CreateContactRequest returns a request value for making API operation for
// Alexa For Business.
//
// Creates a contact with the specified details.
//
//    // Example sending a request using the CreateContactRequest method.
//    req := client.CreateContactRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateContact
func (c *AlexaForBusiness) CreateContactRequest(input *CreateContactInput) CreateContactRequest {
	op := &aws.Operation{
		Name:       opCreateContact,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateContactInput{}
	}

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

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

const opCreateProfile = "CreateProfile"

// CreateProfileRequest is a API request type for the CreateProfile API operation.
type CreateProfileRequest struct {
	*aws.Request
	Input *CreateProfileInput
	Copy  func(*CreateProfileInput) CreateProfileRequest
}

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

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

// CreateProfileRequest returns a request value for making API operation for
// Alexa For Business.
//
// Creates a new room profile with the specified details.
//
//    // Example sending a request using the CreateProfileRequest method.
//    req := client.CreateProfileRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateProfile
func (c *AlexaForBusiness) CreateProfileRequest(input *CreateProfileInput) CreateProfileRequest {
	op := &aws.Operation{
		Name:       opCreateProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateProfileInput{}
	}

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

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

const opCreateRoom = "CreateRoom"

// CreateRoomRequest is a API request type for the CreateRoom API operation.
type CreateRoomRequest struct {
	*aws.Request
	Input *CreateRoomInput
	Copy  func(*CreateRoomInput) CreateRoomRequest
}

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

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

// CreateRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Creates a room with the specified details.
//
//    // Example sending a request using the CreateRoomRequest method.
//    req := client.CreateRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateRoom
func (c *AlexaForBusiness) CreateRoomRequest(input *CreateRoomInput) CreateRoomRequest {
	op := &aws.Operation{
		Name:       opCreateRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateRoomInput{}
	}

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

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

const opCreateSkillGroup = "CreateSkillGroup"

// CreateSkillGroupRequest is a API request type for the CreateSkillGroup API operation.
type CreateSkillGroupRequest struct {
	*aws.Request
	Input *CreateSkillGroupInput
	Copy  func(*CreateSkillGroupInput) CreateSkillGroupRequest
}

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

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

// CreateSkillGroupRequest returns a request value for making API operation for
// Alexa For Business.
//
// Creates a skill group with a specified name and description.
//
//    // Example sending a request using the CreateSkillGroupRequest method.
//    req := client.CreateSkillGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateSkillGroup
func (c *AlexaForBusiness) CreateSkillGroupRequest(input *CreateSkillGroupInput) CreateSkillGroupRequest {
	op := &aws.Operation{
		Name:       opCreateSkillGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateSkillGroupInput{}
	}

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

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

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
// Alexa For Business.
//
// Creates a user.
//
//    // 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/alexaforbusiness-2017-11-09/CreateUser
func (c *AlexaForBusiness) 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 opDeleteAddressBook = "DeleteAddressBook"

// DeleteAddressBookRequest is a API request type for the DeleteAddressBook API operation.
type DeleteAddressBookRequest struct {
	*aws.Request
	Input *DeleteAddressBookInput
	Copy  func(*DeleteAddressBookInput) DeleteAddressBookRequest
}

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

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

// DeleteAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes an address book by the address book ARN.
//
//    // Example sending a request using the DeleteAddressBookRequest method.
//    req := client.DeleteAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteAddressBook
func (c *AlexaForBusiness) DeleteAddressBookRequest(input *DeleteAddressBookInput) DeleteAddressBookRequest {
	op := &aws.Operation{
		Name:       opDeleteAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteAddressBookInput{}
	}

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

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

const opDeleteContact = "DeleteContact"

// DeleteContactRequest is a API request type for the DeleteContact API operation.
type DeleteContactRequest struct {
	*aws.Request
	Input *DeleteContactInput
	Copy  func(*DeleteContactInput) DeleteContactRequest
}

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

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

// DeleteContactRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes a contact by the contact ARN.
//
//    // Example sending a request using the DeleteContactRequest method.
//    req := client.DeleteContactRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteContact
func (c *AlexaForBusiness) DeleteContactRequest(input *DeleteContactInput) DeleteContactRequest {
	op := &aws.Operation{
		Name:       opDeleteContact,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteContactInput{}
	}

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

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

const opDeleteProfile = "DeleteProfile"

// DeleteProfileRequest is a API request type for the DeleteProfile API operation.
type DeleteProfileRequest struct {
	*aws.Request
	Input *DeleteProfileInput
	Copy  func(*DeleteProfileInput) DeleteProfileRequest
}

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

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

// DeleteProfileRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes a room profile by the profile ARN.
//
//    // Example sending a request using the DeleteProfileRequest method.
//    req := client.DeleteProfileRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteProfile
func (c *AlexaForBusiness) DeleteProfileRequest(input *DeleteProfileInput) DeleteProfileRequest {
	op := &aws.Operation{
		Name:       opDeleteProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteProfileInput{}
	}

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

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

const opDeleteRoom = "DeleteRoom"

// DeleteRoomRequest is a API request type for the DeleteRoom API operation.
type DeleteRoomRequest struct {
	*aws.Request
	Input *DeleteRoomInput
	Copy  func(*DeleteRoomInput) DeleteRoomRequest
}

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

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

// DeleteRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes a room by the room ARN.
//
//    // Example sending a request using the DeleteRoomRequest method.
//    req := client.DeleteRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoom
func (c *AlexaForBusiness) DeleteRoomRequest(input *DeleteRoomInput) DeleteRoomRequest {
	op := &aws.Operation{
		Name:       opDeleteRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteRoomInput{}
	}

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

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

const opDeleteRoomSkillParameter = "DeleteRoomSkillParameter"

// DeleteRoomSkillParameterRequest is a API request type for the DeleteRoomSkillParameter API operation.
type DeleteRoomSkillParameterRequest struct {
	*aws.Request
	Input *DeleteRoomSkillParameterInput
	Copy  func(*DeleteRoomSkillParameterInput) DeleteRoomSkillParameterRequest
}

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

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

// DeleteRoomSkillParameterRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes room skill parameter details by room, skill, and parameter key ID.
//
//    // Example sending a request using the DeleteRoomSkillParameterRequest method.
//    req := client.DeleteRoomSkillParameterRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoomSkillParameter
func (c *AlexaForBusiness) DeleteRoomSkillParameterRequest(input *DeleteRoomSkillParameterInput) DeleteRoomSkillParameterRequest {
	op := &aws.Operation{
		Name:       opDeleteRoomSkillParameter,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteRoomSkillParameterInput{}
	}

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

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

const opDeleteSkillGroup = "DeleteSkillGroup"

// DeleteSkillGroupRequest is a API request type for the DeleteSkillGroup API operation.
type DeleteSkillGroupRequest struct {
	*aws.Request
	Input *DeleteSkillGroupInput
	Copy  func(*DeleteSkillGroupInput) DeleteSkillGroupRequest
}

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

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

// DeleteSkillGroupRequest returns a request value for making API operation for
// Alexa For Business.
//
// Deletes a skill group by skill group ARN.
//
//    // Example sending a request using the DeleteSkillGroupRequest method.
//    req := client.DeleteSkillGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteSkillGroup
func (c *AlexaForBusiness) DeleteSkillGroupRequest(input *DeleteSkillGroupInput) DeleteSkillGroupRequest {
	op := &aws.Operation{
		Name:       opDeleteSkillGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSkillGroupInput{}
	}

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

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

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
// Alexa For Business.
//
// Deletes a specified user by user ARN and enrollment ARN.
//
//    // 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/alexaforbusiness-2017-11-09/DeleteUser
func (c *AlexaForBusiness) 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 opDisassociateContactFromAddressBook = "DisassociateContactFromAddressBook"

// DisassociateContactFromAddressBookRequest is a API request type for the DisassociateContactFromAddressBook API operation.
type DisassociateContactFromAddressBookRequest struct {
	*aws.Request
	Input *DisassociateContactFromAddressBookInput
	Copy  func(*DisassociateContactFromAddressBookInput) DisassociateContactFromAddressBookRequest
}

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

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

// DisassociateContactFromAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Disassociates a contact from a given address book.
//
//    // Example sending a request using the DisassociateContactFromAddressBookRequest method.
//    req := client.DisassociateContactFromAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateContactFromAddressBook
func (c *AlexaForBusiness) DisassociateContactFromAddressBookRequest(input *DisassociateContactFromAddressBookInput) DisassociateContactFromAddressBookRequest {
	op := &aws.Operation{
		Name:       opDisassociateContactFromAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateContactFromAddressBookInput{}
	}

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

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

const opDisassociateDeviceFromRoom = "DisassociateDeviceFromRoom"

// DisassociateDeviceFromRoomRequest is a API request type for the DisassociateDeviceFromRoom API operation.
type DisassociateDeviceFromRoomRequest struct {
	*aws.Request
	Input *DisassociateDeviceFromRoomInput
	Copy  func(*DisassociateDeviceFromRoomInput) DisassociateDeviceFromRoomRequest
}

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

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

// DisassociateDeviceFromRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Disassociates a device from its current room. The device continues to be
// connected to the Wi-Fi network and is still registered to the account. The
// device settings and skills are removed from the room.
//
//    // Example sending a request using the DisassociateDeviceFromRoomRequest method.
//    req := client.DisassociateDeviceFromRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateDeviceFromRoom
func (c *AlexaForBusiness) DisassociateDeviceFromRoomRequest(input *DisassociateDeviceFromRoomInput) DisassociateDeviceFromRoomRequest {
	op := &aws.Operation{
		Name:       opDisassociateDeviceFromRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateDeviceFromRoomInput{}
	}

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

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

const opDisassociateSkillGroupFromRoom = "DisassociateSkillGroupFromRoom"

// DisassociateSkillGroupFromRoomRequest is a API request type for the DisassociateSkillGroupFromRoom API operation.
type DisassociateSkillGroupFromRoomRequest struct {
	*aws.Request
	Input *DisassociateSkillGroupFromRoomInput
	Copy  func(*DisassociateSkillGroupFromRoomInput) DisassociateSkillGroupFromRoomRequest
}

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

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

// DisassociateSkillGroupFromRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Disassociates a skill group from a specified room. This disables all skills
// in the skill group on all devices in the room.
//
//    // Example sending a request using the DisassociateSkillGroupFromRoomRequest method.
//    req := client.DisassociateSkillGroupFromRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateSkillGroupFromRoom
func (c *AlexaForBusiness) DisassociateSkillGroupFromRoomRequest(input *DisassociateSkillGroupFromRoomInput) DisassociateSkillGroupFromRoomRequest {
	op := &aws.Operation{
		Name:       opDisassociateSkillGroupFromRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DisassociateSkillGroupFromRoomInput{}
	}

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

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

const opGetAddressBook = "GetAddressBook"

// GetAddressBookRequest is a API request type for the GetAddressBook API operation.
type GetAddressBookRequest struct {
	*aws.Request
	Input *GetAddressBookInput
	Copy  func(*GetAddressBookInput) GetAddressBookRequest
}

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

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

// GetAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets address the book details by the address book ARN.
//
//    // Example sending a request using the GetAddressBookRequest method.
//    req := client.GetAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetAddressBook
func (c *AlexaForBusiness) GetAddressBookRequest(input *GetAddressBookInput) GetAddressBookRequest {
	op := &aws.Operation{
		Name:       opGetAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetAddressBookInput{}
	}

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

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

const opGetContact = "GetContact"

// GetContactRequest is a API request type for the GetContact API operation.
type GetContactRequest struct {
	*aws.Request
	Input *GetContactInput
	Copy  func(*GetContactInput) GetContactRequest
}

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

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

// GetContactRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets the contact details by the contact ARN.
//
//    // Example sending a request using the GetContactRequest method.
//    req := client.GetContactRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetContact
func (c *AlexaForBusiness) GetContactRequest(input *GetContactInput) GetContactRequest {
	op := &aws.Operation{
		Name:       opGetContact,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetContactInput{}
	}

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

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

const opGetDevice = "GetDevice"

// GetDeviceRequest is a API request type for the GetDevice API operation.
type GetDeviceRequest struct {
	*aws.Request
	Input *GetDeviceInput
	Copy  func(*GetDeviceInput) GetDeviceRequest
}

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

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

// GetDeviceRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets the details of a device by device ARN.
//
//    // Example sending a request using the GetDeviceRequest method.
//    req := client.GetDeviceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetDevice
func (c *AlexaForBusiness) GetDeviceRequest(input *GetDeviceInput) GetDeviceRequest {
	op := &aws.Operation{
		Name:       opGetDevice,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDeviceInput{}
	}

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

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

const opGetProfile = "GetProfile"

// GetProfileRequest is a API request type for the GetProfile API operation.
type GetProfileRequest struct {
	*aws.Request
	Input *GetProfileInput
	Copy  func(*GetProfileInput) GetProfileRequest
}

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

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

// GetProfileRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets the details of a room profile by profile ARN.
//
//    // Example sending a request using the GetProfileRequest method.
//    req := client.GetProfileRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetProfile
func (c *AlexaForBusiness) GetProfileRequest(input *GetProfileInput) GetProfileRequest {
	op := &aws.Operation{
		Name:       opGetProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetProfileInput{}
	}

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

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

const opGetRoom = "GetRoom"

// GetRoomRequest is a API request type for the GetRoom API operation.
type GetRoomRequest struct {
	*aws.Request
	Input *GetRoomInput
	Copy  func(*GetRoomInput) GetRoomRequest
}

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

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

// GetRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets room details by room ARN.
//
//    // Example sending a request using the GetRoomRequest method.
//    req := client.GetRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoom
func (c *AlexaForBusiness) GetRoomRequest(input *GetRoomInput) GetRoomRequest {
	op := &aws.Operation{
		Name:       opGetRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetRoomInput{}
	}

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

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

const opGetRoomSkillParameter = "GetRoomSkillParameter"

// GetRoomSkillParameterRequest is a API request type for the GetRoomSkillParameter API operation.
type GetRoomSkillParameterRequest struct {
	*aws.Request
	Input *GetRoomSkillParameterInput
	Copy  func(*GetRoomSkillParameterInput) GetRoomSkillParameterRequest
}

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

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

// GetRoomSkillParameterRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets room skill parameter details by room, skill, and parameter key ARN.
//
//    // Example sending a request using the GetRoomSkillParameterRequest method.
//    req := client.GetRoomSkillParameterRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoomSkillParameter
func (c *AlexaForBusiness) GetRoomSkillParameterRequest(input *GetRoomSkillParameterInput) GetRoomSkillParameterRequest {
	op := &aws.Operation{
		Name:       opGetRoomSkillParameter,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetRoomSkillParameterInput{}
	}

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

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

const opGetSkillGroup = "GetSkillGroup"

// GetSkillGroupRequest is a API request type for the GetSkillGroup API operation.
type GetSkillGroupRequest struct {
	*aws.Request
	Input *GetSkillGroupInput
	Copy  func(*GetSkillGroupInput) GetSkillGroupRequest
}

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

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

// GetSkillGroupRequest returns a request value for making API operation for
// Alexa For Business.
//
// Gets skill group details by skill group ARN.
//
//    // Example sending a request using the GetSkillGroupRequest method.
//    req := client.GetSkillGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetSkillGroup
func (c *AlexaForBusiness) GetSkillGroupRequest(input *GetSkillGroupInput) GetSkillGroupRequest {
	op := &aws.Operation{
		Name:       opGetSkillGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSkillGroupInput{}
	}

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

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

const opListDeviceEvents = "ListDeviceEvents"

// ListDeviceEventsRequest is a API request type for the ListDeviceEvents API operation.
type ListDeviceEventsRequest struct {
	*aws.Request
	Input *ListDeviceEventsInput
	Copy  func(*ListDeviceEventsInput) ListDeviceEventsRequest
}

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

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

// ListDeviceEventsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Lists the Device Event history for up to 30 days. If EventType isn't specified
// in the request, this returns a list of all device events in reverse chronological
// order. If EventType is specified, this returns a list of device events for
// that EventType in reverse chronological order.
//
//    // Example sending a request using the ListDeviceEventsRequest method.
//    req := client.ListDeviceEventsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListDeviceEvents
func (c *AlexaForBusiness) ListDeviceEventsRequest(input *ListDeviceEventsInput) ListDeviceEventsRequest {
	op := &aws.Operation{
		Name:       opListDeviceEvents,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListDeviceEventsInput{}
	}

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

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

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

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

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

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

func (p *ListDeviceEventsPager) CurrentPage() *ListDeviceEventsOutput {
	return p.Pager.CurrentPage().(*ListDeviceEventsOutput)
}

const opListSkills = "ListSkills"

// ListSkillsRequest is a API request type for the ListSkills API operation.
type ListSkillsRequest struct {
	*aws.Request
	Input *ListSkillsInput
	Copy  func(*ListSkillsInput) ListSkillsRequest
}

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

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

// ListSkillsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Lists all enabled skills in a specific skill group.
//
//    // Example sending a request using the ListSkillsRequest method.
//    req := client.ListSkillsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListSkills
func (c *AlexaForBusiness) ListSkillsRequest(input *ListSkillsInput) ListSkillsRequest {
	op := &aws.Operation{
		Name:       opListSkills,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListSkillsInput{}
	}

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

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

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

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

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

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

func (p *ListSkillsPager) CurrentPage() *ListSkillsOutput {
	return p.Pager.CurrentPage().(*ListSkillsOutput)
}

const opListTags = "ListTags"

// ListTagsRequest is a API request type for the ListTags API operation.
type ListTagsRequest struct {
	*aws.Request
	Input *ListTagsInput
	Copy  func(*ListTagsInput) ListTagsRequest
}

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

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

// ListTagsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Lists all tags for a specific resource.
//
//    // Example sending a request using the ListTagsRequest method.
//    req := client.ListTagsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListTags
func (c *AlexaForBusiness) ListTagsRequest(input *ListTagsInput) ListTagsRequest {
	op := &aws.Operation{
		Name:       opListTags,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListTagsInput{}
	}

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

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

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

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

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

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

func (p *ListTagsPager) CurrentPage() *ListTagsOutput {
	return p.Pager.CurrentPage().(*ListTagsOutput)
}

const opPutRoomSkillParameter = "PutRoomSkillParameter"

// PutRoomSkillParameterRequest is a API request type for the PutRoomSkillParameter API operation.
type PutRoomSkillParameterRequest struct {
	*aws.Request
	Input *PutRoomSkillParameterInput
	Copy  func(*PutRoomSkillParameterInput) PutRoomSkillParameterRequest
}

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

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

// PutRoomSkillParameterRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates room skill parameter details by room, skill, and parameter key ID.
// Not all skills have a room skill parameter.
//
//    // Example sending a request using the PutRoomSkillParameterRequest method.
//    req := client.PutRoomSkillParameterRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/PutRoomSkillParameter
func (c *AlexaForBusiness) PutRoomSkillParameterRequest(input *PutRoomSkillParameterInput) PutRoomSkillParameterRequest {
	op := &aws.Operation{
		Name:       opPutRoomSkillParameter,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &PutRoomSkillParameterInput{}
	}

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

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

const opResolveRoom = "ResolveRoom"

// ResolveRoomRequest is a API request type for the ResolveRoom API operation.
type ResolveRoomRequest struct {
	*aws.Request
	Input *ResolveRoomInput
	Copy  func(*ResolveRoomInput) ResolveRoomRequest
}

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

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

// ResolveRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Determines the details for the room from which a skill request was invoked.
// This operation is used by skill developers.
//
//    // Example sending a request using the ResolveRoomRequest method.
//    req := client.ResolveRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ResolveRoom
func (c *AlexaForBusiness) ResolveRoomRequest(input *ResolveRoomInput) ResolveRoomRequest {
	op := &aws.Operation{
		Name:       opResolveRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ResolveRoomInput{}
	}

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

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

const opRevokeInvitation = "RevokeInvitation"

// RevokeInvitationRequest is a API request type for the RevokeInvitation API operation.
type RevokeInvitationRequest struct {
	*aws.Request
	Input *RevokeInvitationInput
	Copy  func(*RevokeInvitationInput) RevokeInvitationRequest
}

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

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

// RevokeInvitationRequest returns a request value for making API operation for
// Alexa For Business.
//
// Revokes an invitation and invalidates the enrollment URL.
//
//    // Example sending a request using the RevokeInvitationRequest method.
//    req := client.RevokeInvitationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/RevokeInvitation
func (c *AlexaForBusiness) RevokeInvitationRequest(input *RevokeInvitationInput) RevokeInvitationRequest {
	op := &aws.Operation{
		Name:       opRevokeInvitation,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &RevokeInvitationInput{}
	}

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

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

const opSearchAddressBooks = "SearchAddressBooks"

// SearchAddressBooksRequest is a API request type for the SearchAddressBooks API operation.
type SearchAddressBooksRequest struct {
	*aws.Request
	Input *SearchAddressBooksInput
	Copy  func(*SearchAddressBooksInput) SearchAddressBooksRequest
}

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

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

// SearchAddressBooksRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches address books and lists the ones that meet a set of filter and sort
// criteria.
//
//    // Example sending a request using the SearchAddressBooksRequest method.
//    req := client.SearchAddressBooksRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchAddressBooks
func (c *AlexaForBusiness) SearchAddressBooksRequest(input *SearchAddressBooksInput) SearchAddressBooksRequest {
	op := &aws.Operation{
		Name:       opSearchAddressBooks,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchAddressBooksInput{}
	}

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

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

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

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

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

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

func (p *SearchAddressBooksPager) CurrentPage() *SearchAddressBooksOutput {
	return p.Pager.CurrentPage().(*SearchAddressBooksOutput)
}

const opSearchContacts = "SearchContacts"

// SearchContactsRequest is a API request type for the SearchContacts API operation.
type SearchContactsRequest struct {
	*aws.Request
	Input *SearchContactsInput
	Copy  func(*SearchContactsInput) SearchContactsRequest
}

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

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

// SearchContactsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches contacts and lists the ones that meet a set of filter and sort criteria.
//
//    // Example sending a request using the SearchContactsRequest method.
//    req := client.SearchContactsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchContacts
func (c *AlexaForBusiness) SearchContactsRequest(input *SearchContactsInput) SearchContactsRequest {
	op := &aws.Operation{
		Name:       opSearchContacts,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchContactsInput{}
	}

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

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

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

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

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

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

func (p *SearchContactsPager) CurrentPage() *SearchContactsOutput {
	return p.Pager.CurrentPage().(*SearchContactsOutput)
}

const opSearchDevices = "SearchDevices"

// SearchDevicesRequest is a API request type for the SearchDevices API operation.
type SearchDevicesRequest struct {
	*aws.Request
	Input *SearchDevicesInput
	Copy  func(*SearchDevicesInput) SearchDevicesRequest
}

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

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

// SearchDevicesRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches devices and lists the ones that meet a set of filter criteria.
//
//    // Example sending a request using the SearchDevicesRequest method.
//    req := client.SearchDevicesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchDevices
func (c *AlexaForBusiness) SearchDevicesRequest(input *SearchDevicesInput) SearchDevicesRequest {
	op := &aws.Operation{
		Name:       opSearchDevices,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchDevicesInput{}
	}

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

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

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

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

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

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

func (p *SearchDevicesPager) CurrentPage() *SearchDevicesOutput {
	return p.Pager.CurrentPage().(*SearchDevicesOutput)
}

const opSearchProfiles = "SearchProfiles"

// SearchProfilesRequest is a API request type for the SearchProfiles API operation.
type SearchProfilesRequest struct {
	*aws.Request
	Input *SearchProfilesInput
	Copy  func(*SearchProfilesInput) SearchProfilesRequest
}

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

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

// SearchProfilesRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches room profiles and lists the ones that meet a set of filter criteria.
//
//    // Example sending a request using the SearchProfilesRequest method.
//    req := client.SearchProfilesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchProfiles
func (c *AlexaForBusiness) SearchProfilesRequest(input *SearchProfilesInput) SearchProfilesRequest {
	op := &aws.Operation{
		Name:       opSearchProfiles,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchProfilesInput{}
	}

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

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

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

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

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

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

func (p *SearchProfilesPager) CurrentPage() *SearchProfilesOutput {
	return p.Pager.CurrentPage().(*SearchProfilesOutput)
}

const opSearchRooms = "SearchRooms"

// SearchRoomsRequest is a API request type for the SearchRooms API operation.
type SearchRoomsRequest struct {
	*aws.Request
	Input *SearchRoomsInput
	Copy  func(*SearchRoomsInput) SearchRoomsRequest
}

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

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

// SearchRoomsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches rooms and lists the ones that meet a set of filter and sort criteria.
//
//    // Example sending a request using the SearchRoomsRequest method.
//    req := client.SearchRoomsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchRooms
func (c *AlexaForBusiness) SearchRoomsRequest(input *SearchRoomsInput) SearchRoomsRequest {
	op := &aws.Operation{
		Name:       opSearchRooms,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchRoomsInput{}
	}

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

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

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

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

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

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

func (p *SearchRoomsPager) CurrentPage() *SearchRoomsOutput {
	return p.Pager.CurrentPage().(*SearchRoomsOutput)
}

const opSearchSkillGroups = "SearchSkillGroups"

// SearchSkillGroupsRequest is a API request type for the SearchSkillGroups API operation.
type SearchSkillGroupsRequest struct {
	*aws.Request
	Input *SearchSkillGroupsInput
	Copy  func(*SearchSkillGroupsInput) SearchSkillGroupsRequest
}

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

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

// SearchSkillGroupsRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches skill groups and lists the ones that meet a set of filter and sort
// criteria.
//
//    // Example sending a request using the SearchSkillGroupsRequest method.
//    req := client.SearchSkillGroupsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchSkillGroups
func (c *AlexaForBusiness) SearchSkillGroupsRequest(input *SearchSkillGroupsInput) SearchSkillGroupsRequest {
	op := &aws.Operation{
		Name:       opSearchSkillGroups,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchSkillGroupsInput{}
	}

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

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

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

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

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

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

func (p *SearchSkillGroupsPager) CurrentPage() *SearchSkillGroupsOutput {
	return p.Pager.CurrentPage().(*SearchSkillGroupsOutput)
}

const opSearchUsers = "SearchUsers"

// SearchUsersRequest is a API request type for the SearchUsers API operation.
type SearchUsersRequest struct {
	*aws.Request
	Input *SearchUsersInput
	Copy  func(*SearchUsersInput) SearchUsersRequest
}

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

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

// SearchUsersRequest returns a request value for making API operation for
// Alexa For Business.
//
// Searches users and lists the ones that meet a set of filter and sort criteria.
//
//    // Example sending a request using the SearchUsersRequest method.
//    req := client.SearchUsersRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchUsers
func (c *AlexaForBusiness) SearchUsersRequest(input *SearchUsersInput) SearchUsersRequest {
	op := &aws.Operation{
		Name:       opSearchUsers,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxResults",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &SearchUsersInput{}
	}

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

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

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

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

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

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

func (p *SearchUsersPager) CurrentPage() *SearchUsersOutput {
	return p.Pager.CurrentPage().(*SearchUsersOutput)
}

const opSendInvitation = "SendInvitation"

// SendInvitationRequest is a API request type for the SendInvitation API operation.
type SendInvitationRequest struct {
	*aws.Request
	Input *SendInvitationInput
	Copy  func(*SendInvitationInput) SendInvitationRequest
}

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

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

// SendInvitationRequest returns a request value for making API operation for
// Alexa For Business.
//
// Sends an enrollment invitation email with a URL to a user. The URL is valid
// for 72 hours or until you call this operation again, whichever comes first.
//
//    // Example sending a request using the SendInvitationRequest method.
//    req := client.SendInvitationRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SendInvitation
func (c *AlexaForBusiness) SendInvitationRequest(input *SendInvitationInput) SendInvitationRequest {
	op := &aws.Operation{
		Name:       opSendInvitation,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SendInvitationInput{}
	}

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

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

const opStartDeviceSync = "StartDeviceSync"

// StartDeviceSyncRequest is a API request type for the StartDeviceSync API operation.
type StartDeviceSyncRequest struct {
	*aws.Request
	Input *StartDeviceSyncInput
	Copy  func(*StartDeviceSyncInput) StartDeviceSyncRequest
}

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

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

// StartDeviceSyncRequest returns a request value for making API operation for
// Alexa For Business.
//
// Resets a device and its account to the known default settings, by clearing
// all information and settings set by previous users.
//
//    // Example sending a request using the StartDeviceSyncRequest method.
//    req := client.StartDeviceSyncRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/StartDeviceSync
func (c *AlexaForBusiness) StartDeviceSyncRequest(input *StartDeviceSyncInput) StartDeviceSyncRequest {
	op := &aws.Operation{
		Name:       opStartDeviceSync,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartDeviceSyncInput{}
	}

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

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

const opTagResource = "TagResource"

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

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

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

// TagResourceRequest returns a request value for making API operation for
// Alexa For Business.
//
// Adds metadata tags to a specified resource.
//
//    // Example sending a request using the TagResourceRequest method.
//    req := client.TagResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/TagResource
func (c *AlexaForBusiness) TagResourceRequest(input *TagResourceInput) TagResourceRequest {
	op := &aws.Operation{
		Name:       opTagResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

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

const opUntagResource = "UntagResource"

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

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

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

// UntagResourceRequest returns a request value for making API operation for
// Alexa For Business.
//
// Removes metadata tags from a specified resource.
//
//    // Example sending a request using the UntagResourceRequest method.
//    req := client.UntagResourceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UntagResource
func (c *AlexaForBusiness) UntagResourceRequest(input *UntagResourceInput) UntagResourceRequest {
	op := &aws.Operation{
		Name:       opUntagResource,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

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

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

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

const opUpdateAddressBook = "UpdateAddressBook"

// UpdateAddressBookRequest is a API request type for the UpdateAddressBook API operation.
type UpdateAddressBookRequest struct {
	*aws.Request
	Input *UpdateAddressBookInput
	Copy  func(*UpdateAddressBookInput) UpdateAddressBookRequest
}

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

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

// UpdateAddressBookRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates address book details by the address book ARN.
//
//    // Example sending a request using the UpdateAddressBookRequest method.
//    req := client.UpdateAddressBookRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateAddressBook
func (c *AlexaForBusiness) UpdateAddressBookRequest(input *UpdateAddressBookInput) UpdateAddressBookRequest {
	op := &aws.Operation{
		Name:       opUpdateAddressBook,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateAddressBookInput{}
	}

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

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

const opUpdateContact = "UpdateContact"

// UpdateContactRequest is a API request type for the UpdateContact API operation.
type UpdateContactRequest struct {
	*aws.Request
	Input *UpdateContactInput
	Copy  func(*UpdateContactInput) UpdateContactRequest
}

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

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

// UpdateContactRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates the contact details by the contact ARN.
//
//    // Example sending a request using the UpdateContactRequest method.
//    req := client.UpdateContactRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateContact
func (c *AlexaForBusiness) UpdateContactRequest(input *UpdateContactInput) UpdateContactRequest {
	op := &aws.Operation{
		Name:       opUpdateContact,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateContactInput{}
	}

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

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

const opUpdateDevice = "UpdateDevice"

// UpdateDeviceRequest is a API request type for the UpdateDevice API operation.
type UpdateDeviceRequest struct {
	*aws.Request
	Input *UpdateDeviceInput
	Copy  func(*UpdateDeviceInput) UpdateDeviceRequest
}

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

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

// UpdateDeviceRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates the device name by device ARN.
//
//    // Example sending a request using the UpdateDeviceRequest method.
//    req := client.UpdateDeviceRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateDevice
func (c *AlexaForBusiness) UpdateDeviceRequest(input *UpdateDeviceInput) UpdateDeviceRequest {
	op := &aws.Operation{
		Name:       opUpdateDevice,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateDeviceInput{}
	}

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

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

const opUpdateProfile = "UpdateProfile"

// UpdateProfileRequest is a API request type for the UpdateProfile API operation.
type UpdateProfileRequest struct {
	*aws.Request
	Input *UpdateProfileInput
	Copy  func(*UpdateProfileInput) UpdateProfileRequest
}

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

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

// UpdateProfileRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates an existing room profile by room profile ARN.
//
//    // Example sending a request using the UpdateProfileRequest method.
//    req := client.UpdateProfileRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateProfile
func (c *AlexaForBusiness) UpdateProfileRequest(input *UpdateProfileInput) UpdateProfileRequest {
	op := &aws.Operation{
		Name:       opUpdateProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateProfileInput{}
	}

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

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

const opUpdateRoom = "UpdateRoom"

// UpdateRoomRequest is a API request type for the UpdateRoom API operation.
type UpdateRoomRequest struct {
	*aws.Request
	Input *UpdateRoomInput
	Copy  func(*UpdateRoomInput) UpdateRoomRequest
}

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

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

// UpdateRoomRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates room details by room ARN.
//
//    // Example sending a request using the UpdateRoomRequest method.
//    req := client.UpdateRoomRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateRoom
func (c *AlexaForBusiness) UpdateRoomRequest(input *UpdateRoomInput) UpdateRoomRequest {
	op := &aws.Operation{
		Name:       opUpdateRoom,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateRoomInput{}
	}

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

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

const opUpdateSkillGroup = "UpdateSkillGroup"

// UpdateSkillGroupRequest is a API request type for the UpdateSkillGroup API operation.
type UpdateSkillGroupRequest struct {
	*aws.Request
	Input *UpdateSkillGroupInput
	Copy  func(*UpdateSkillGroupInput) UpdateSkillGroupRequest
}

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

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

// UpdateSkillGroupRequest returns a request value for making API operation for
// Alexa For Business.
//
// Updates skill group details by skill group ARN.
//
//    // Example sending a request using the UpdateSkillGroupRequest method.
//    req := client.UpdateSkillGroupRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateSkillGroup
func (c *AlexaForBusiness) UpdateSkillGroupRequest(input *UpdateSkillGroupInput) UpdateSkillGroupRequest {
	op := &aws.Operation{
		Name:       opUpdateSkillGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateSkillGroupInput{}
	}

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

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

// An address book with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AddressBook
type AddressBook struct {
	_ struct{} `type:"structure"`

	// The ARN of the address book.
	AddressBookArn *string `type:"string"`

	// The description of the address book.
	Description *string `min:"1" type:"string"`

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

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

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

// Information related to an address book.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AddressBookData
type AddressBookData struct {
	_ struct{} `type:"structure"`

	// The ARN of the address book.
	AddressBookArn *string `type:"string"`

	// The description of the address book.
	Description *string `min:"1" type:"string"`

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateContactWithAddressBookRequest
type AssociateContactWithAddressBookInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the address book with which to associate the contact.
	//
	// AddressBookArn is a required field
	AddressBookArn *string `type:"string" required:"true"`

	// The ARN of the contact to associate with an address book.
	//
	// ContactArn is a required field
	ContactArn *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateContactWithAddressBookResponse
type AssociateContactWithAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateDeviceWithRoomRequest
type AssociateDeviceWithRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the device to associate to a room. Required.
	DeviceArn *string `type:"string"`

	// The ARN of the room with which to associate the device. Required.
	RoomArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateDeviceWithRoomResponse
type AssociateDeviceWithRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateSkillGroupWithRoomRequest
type AssociateSkillGroupWithRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room with which to associate the skill group. Required.
	RoomArn *string `type:"string"`

	// The ARN of the skill group to associate with a room. Required.
	SkillGroupArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/AssociateSkillGroupWithRoomResponse
type AssociateSkillGroupWithRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// A contact with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Contact
type Contact struct {
	_ struct{} `type:"structure"`

	// The ARN of the contact.
	ContactArn *string `type:"string"`

	// The name of the contact to display on the console.
	DisplayName *string `min:"1" type:"string"`

	// The first name of the contact, used to call the contact on the device.
	FirstName *string `min:"1" type:"string"`

	// The last name of the contact, used to call the contact on the device.
	LastName *string `min:"1" type:"string"`

	// The phone number of the contact.
	PhoneNumber *string `type:"string"`
}

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

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

// Information related to a contact.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ContactData
type ContactData struct {
	_ struct{} `type:"structure"`

	// The ARN of the contact.
	ContactArn *string `type:"string"`

	// The name of the contact to display on the console.
	DisplayName *string `min:"1" type:"string"`

	// The first name of the contact, used to call the contact on the device.
	FirstName *string `min:"1" type:"string"`

	// The last name of the contact, used to call the contact on the device.
	LastName *string `min:"1" type:"string"`

	// The phone number of the contact.
	PhoneNumber *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateAddressBookRequest
type CreateAddressBookInput struct {
	_ struct{} `type:"structure"`

	// A unique, user-specified identifier for the request that ensures idempotency.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

	// The description of the address book.
	Description *string `min:"1" type:"string"`

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateAddressBookResponse
type CreateAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the newly created address book.
	AddressBookArn *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateContactRequest
type CreateContactInput struct {
	_ struct{} `type:"structure"`

	// A unique, user-specified identifier for this request that ensures idempotency.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

	// The name of the contact to display on the console.
	DisplayName *string `min:"1" type:"string"`

	// The first name of the contact that is used to call the contact on the device.
	//
	// FirstName is a required field
	FirstName *string `min:"1" type:"string" required:"true"`

	// The last name of the contact that is used to call the contact on the device.
	LastName *string `min:"1" type:"string"`

	// The phone number of the contact in E.164 format.
	//
	// PhoneNumber is a required field
	PhoneNumber *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateContactResponse
type CreateContactOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the newly created address book.
	ContactArn *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateProfileRequest
type CreateProfileInput struct {
	_ struct{} `type:"structure"`

	// The valid address for the room.
	//
	// Address is a required field
	Address *string `min:"1" type:"string" required:"true"`

	// The user-specified token that is used during the creation of a profile.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

	// The distance unit to be used by devices in the profile.
	//
	// DistanceUnit is a required field
	DistanceUnit DistanceUnit `type:"string" required:"true" enum:"true"`

	// The maximum volume limit for a room profile.
	MaxVolumeLimit *int64 `type:"integer"`

	// Whether PSTN calling is enabled.
	PSTNEnabled *bool `type:"boolean"`

	// The name of a room profile.
	//
	// ProfileName is a required field
	ProfileName *string `min:"1" type:"string" required:"true"`

	// Whether room profile setup is enabled.
	SetupModeDisabled *bool `type:"boolean"`

	// The temperature unit to be used by devices in the profile.
	//
	// TemperatureUnit is a required field
	TemperatureUnit TemperatureUnit `type:"string" required:"true" enum:"true"`

	// The time zone used by a room profile.
	//
	// Timezone is a required field
	Timezone *string `min:"1" type:"string" required:"true"`

	// A wake word for Alexa, Echo, Amazon, or a computer.
	//
	// WakeWord is a required field
	WakeWord WakeWord `type:"string" required:"true" enum:"true"`
}

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

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

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

	if s.Address == nil {
		invalidParams.Add(aws.NewErrParamRequired("Address"))
	}
	if s.Address != nil && len(*s.Address) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Address", 1))
	}
	if s.ClientRequestToken != nil && len(*s.ClientRequestToken) < 10 {
		invalidParams.Add(aws.NewErrParamMinLen("ClientRequestToken", 10))
	}
	if len(s.DistanceUnit) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("DistanceUnit"))
	}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateProfileResponse
type CreateProfileOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the newly created room profile in the response.
	ProfileArn *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateRoomRequest
type CreateRoomInput struct {
	_ struct{} `type:"structure"`

	// A unique, user-specified identifier for this request that ensures idempotency.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

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

	// The profile ARN for the room.
	ProfileArn *string `type:"string"`

	// The calendar ARN for the room.
	ProviderCalendarId *string `type:"string"`

	// The name for the room.
	//
	// RoomName is a required field
	RoomName *string `min:"1" type:"string" required:"true"`

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateRoomResponse
type CreateRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the newly created room in the response.
	RoomArn *string `type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateSkillGroupRequest
type CreateSkillGroupInput struct {
	_ struct{} `type:"structure"`

	// A unique, user-specified identifier for this request that ensures idempotency.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

	// The description for the skill group.
	Description *string `min:"1" type:"string"`

	// The name for the skill group.
	//
	// SkillGroupName is a required field
	SkillGroupName *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/CreateSkillGroupResponse
type CreateSkillGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the newly created skill group in the response.
	SkillGroupArn *string `type:"string"`
}

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

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

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

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

	// A unique, user-specified identifier for this request that ensures idempotency.
	ClientRequestToken *string `min:"10" type:"string" idempotencyToken:"true"`

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

	// The first name for the user.
	FirstName *string `type:"string"`

	// The last name for the user.
	LastName *string `type:"string"`

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

	// The ARN for the user.
	//
	// UserId is a required field
	UserId *string `min:"1" 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.ClientRequestToken != nil && len(*s.ClientRequestToken) < 10 {
		invalidParams.Add(aws.NewErrParamMinLen("ClientRequestToken", 10))
	}
	if s.Email != nil && len(*s.Email) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Email", 1))
	}

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

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

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

	responseMetadata aws.Response

	// The ARN of the newly created user in the response.
	UserArn *string `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
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteAddressBookRequest
type DeleteAddressBookInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the address book to delete.
	//
	// AddressBookArn is a required field
	AddressBookArn *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteAddressBookResponse
type DeleteAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteContactRequest
type DeleteContactInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the contact to delete.
	//
	// ContactArn is a required field
	ContactArn *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteContactResponse
type DeleteContactOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteProfileRequest
type DeleteProfileInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room profile to delete. Required.
	ProfileArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteProfileResponse
type DeleteProfileOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoomRequest
type DeleteRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room to delete. Required.
	RoomArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoomResponse
type DeleteRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoomSkillParameterRequest
type DeleteRoomSkillParameterInput struct {
	_ struct{} `type:"structure"`

	// The room skill parameter key for which to remove details.
	//
	// ParameterKey is a required field
	ParameterKey *string `min:"1" type:"string" required:"true"`

	// The ARN of the room from which to remove the room skill parameter details.
	RoomArn *string `type:"string"`

	// The ID of the skill from which to remove the room skill parameter details.
	//
	// SkillId is a required field
	SkillId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteRoomSkillParameterResponse
type DeleteRoomSkillParameterOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteSkillGroupRequest
type DeleteSkillGroupInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the skill group to delete. Required.
	SkillGroupArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeleteSkillGroupResponse
type DeleteSkillGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

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

	// The ARN of the user's enrollment in the organization. Required.
	//
	// EnrollmentId is a required field
	EnrollmentId *string `type:"string" required:"true"`

	// The ARN of the user to delete in the organization. Required.
	UserArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/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
}

// A device with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Device
type Device struct {
	_ struct{} `type:"structure"`

	// The ARN of a device.
	DeviceArn *string `type:"string"`

	// The name of a device.
	DeviceName *string `min:"2" type:"string"`

	// The serial number of a device.
	DeviceSerialNumber *string `type:"string"`

	// The status of a device. If the status is not READY, check the DeviceStatusInfo
	// value for details.
	DeviceStatus DeviceStatus `type:"string" enum:"true"`

	// Detailed information about a device's status.
	DeviceStatusInfo *DeviceStatusInfo `type:"structure"`

	// The type of a device.
	DeviceType *string `type:"string"`

	// The MAC address of a device.
	MacAddress *string `type:"string"`

	// The room ARN of a device.
	RoomArn *string `type:"string"`

	// The software version of a device.
	SoftwareVersion *string `type:"string"`
}

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

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

// Device attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeviceData
type DeviceData struct {
	_ struct{} `type:"structure"`

	// The ARN of a device.
	DeviceArn *string `type:"string"`

	// The name of a device.
	DeviceName *string `min:"2" type:"string"`

	// The serial number of a device.
	DeviceSerialNumber *string `type:"string"`

	// The status of a device.
	DeviceStatus DeviceStatus `type:"string" enum:"true"`

	// Detailed information about a device's status.
	DeviceStatusInfo *DeviceStatusInfo `type:"structure"`

	// The type of a device.
	DeviceType *string `type:"string"`

	// The MAC address of a device.
	MacAddress *string `type:"string"`

	// The room ARN associated with a device.
	RoomArn *string `type:"string"`

	// The name of the room associated with a device.
	RoomName *string `min:"1" type:"string"`

	// The software version of a device.
	SoftwareVersion *string `type:"string"`
}

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

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

// The list of device events.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeviceEvent
type DeviceEvent struct {
	_ struct{} `type:"structure"`

	// The time (in epoch) when the event occurred.
	Timestamp *time.Time `type:"timestamp" timestampFormat:"unix"`

	// The type of device event.
	Type DeviceEventType `type:"string" enum:"true"`

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

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

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

// Details of a device’s status.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeviceStatusDetail
type DeviceStatusDetail struct {
	_ struct{} `type:"structure"`

	// The device status detail code.
	Code DeviceStatusDetailCode `type:"string" enum:"true"`
}

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

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

// Detailed information about a device's status.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DeviceStatusInfo
type DeviceStatusInfo struct {
	_ struct{} `type:"structure"`

	// The latest available information about the connection status of a device.
	ConnectionStatus ConnectionStatus `type:"string" enum:"true"`

	// One or more device status detail descriptions.
	DeviceStatusDetails []DeviceStatusDetail `type:"list"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateContactFromAddressBookRequest
type DisassociateContactFromAddressBookInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the address from which to disassociate the contact.
	//
	// AddressBookArn is a required field
	AddressBookArn *string `type:"string" required:"true"`

	// The ARN of the contact to disassociate from an address book.
	//
	// ContactArn is a required field
	ContactArn *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateContactFromAddressBookResponse
type DisassociateContactFromAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateDeviceFromRoomRequest
type DisassociateDeviceFromRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the device to disassociate from a room. Required.
	DeviceArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateDeviceFromRoomResponse
type DisassociateDeviceFromRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateSkillGroupFromRoomRequest
type DisassociateSkillGroupFromRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room from which the skill group is to be disassociated. Required.
	RoomArn *string `type:"string"`

	// The ARN of the skill group to disassociate from a room. Required.
	SkillGroupArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/DisassociateSkillGroupFromRoomResponse
type DisassociateSkillGroupFromRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// A filter name and value pair that is used to return a more specific list
// of results. Filters can be used to match a set of resources by various criteria.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Filter
type Filter struct {
	_ struct{} `type:"structure"`

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

	// The values of a filter.
	//
	// Values is a required field
	Values []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetAddressBookRequest
type GetAddressBookInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the address book for which to request details.
	//
	// AddressBookArn is a required field
	AddressBookArn *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetAddressBookResponse
type GetAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the requested address book.
	AddressBook *AddressBook `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetContactRequest
type GetContactInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the contact for which to request details.
	//
	// ContactArn is a required field
	ContactArn *string `type:"string" required:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetContactResponse
type GetContactOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the requested contact.
	Contact *Contact `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetDeviceRequest
type GetDeviceInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the device for which to request details. Required.
	DeviceArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetDeviceResponse
type GetDeviceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the device requested. Required.
	Device *Device `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetProfileRequest
type GetProfileInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room profile for which to request details. Required.
	ProfileArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetProfileResponse
type GetProfileOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the room profile requested. Required.
	Profile *Profile `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoomRequest
type GetRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room for which to request details. Required.
	RoomArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoomResponse
type GetRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the room requested.
	Room *Room `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoomSkillParameterRequest
type GetRoomSkillParameterInput struct {
	_ struct{} `type:"structure"`

	// The room skill parameter key for which to get details. Required.
	//
	// ParameterKey is a required field
	ParameterKey *string `min:"1" type:"string" required:"true"`

	// The ARN of the room from which to get the room skill parameter details.
	RoomArn *string `type:"string"`

	// The ARN of the skill from which to get the room skill parameter details.
	// Required.
	//
	// SkillId is a required field
	SkillId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetRoomSkillParameterResponse
type GetRoomSkillParameterOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the room skill parameter requested. Required.
	RoomSkillParameter *RoomSkillParameter `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetSkillGroupRequest
type GetSkillGroupInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the skill group for which to get details. Required.
	SkillGroupArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/GetSkillGroupResponse
type GetSkillGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The details of the skill group requested. Required.
	SkillGroup *SkillGroup `type:"structure"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListDeviceEventsRequest
type ListDeviceEventsInput struct {
	_ struct{} `type:"structure"`

	// The ARN of a device.
	//
	// DeviceArn is a required field
	DeviceArn *string `type:"string" required:"true"`

	// The event type to filter device events.
	EventType DeviceEventType `type:"string" enum:"true"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved. Required.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// only includes results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

	if s.DeviceArn == nil {
		invalidParams.Add(aws.NewErrParamRequired("DeviceArn"))
	}
	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/alexaforbusiness-2017-11-09/ListDeviceEventsResponse
type ListDeviceEventsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	DeviceEvents []DeviceEvent `type:"list"`

	NextToken *string `min:"1" type:"string"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListSkillsRequest
type ListSkillsInput struct {
	_ struct{} `type:"structure"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved. Required.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	// Required.
	NextToken *string `min:"1" type:"string"`

	// The ARN of the skill group for which to list enabled skills. Required.
	SkillGroupArn *string `type:"string"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListSkillsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListSkillsInput"}
	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/alexaforbusiness-2017-11-09/ListSkillsResponse
type ListSkillsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The list of enabled skills requested. Required.
	SkillSummaries []SkillSummary `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ListTagsRequest
type ListTagsInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the specific resource for which to list tags. Required.
	//
	// Arn is a required field
	Arn *string `type:"string" required:"true"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`
}

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

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

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

	if s.Arn == nil {
		invalidParams.Add(aws.NewErrParamRequired("Arn"))
	}
	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/alexaforbusiness-2017-11-09/ListTagsResponse
type ListTagsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The list of tags requested for the specific resource.
	Tags []Tag `type:"list"`
}

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

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

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

// A room profile with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Profile
type Profile struct {
	_ struct{} `type:"structure"`

	// The address of a room profile.
	Address *string `min:"1" type:"string"`

	// The distance unit of a room profile.
	DistanceUnit DistanceUnit `type:"string" enum:"true"`

	// The max volume limit of a room profile.
	MaxVolumeLimit *int64 `type:"integer"`

	// The PSTN setting of a room profile.
	PSTNEnabled *bool `type:"boolean"`

	// The ARN of a room profile.
	ProfileArn *string `type:"string"`

	// The name of a room profile.
	ProfileName *string `min:"1" type:"string"`

	// The setup mode of a room profile.
	SetupModeDisabled *bool `type:"boolean"`

	// The temperature unit of a room profile.
	TemperatureUnit TemperatureUnit `type:"string" enum:"true"`

	// The time zone of a room profile.
	Timezone *string `min:"1" type:"string"`

	// The wake word of a room profile.
	WakeWord WakeWord `type:"string" enum:"true"`
}

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

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

// The data of a room profile.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ProfileData
type ProfileData struct {
	_ struct{} `type:"structure"`

	// The address of a room profile.
	Address *string `min:"1" type:"string"`

	// The distance unit of a room profile.
	DistanceUnit DistanceUnit `type:"string" enum:"true"`

	// The ARN of a room profile.
	ProfileArn *string `type:"string"`

	// The name of a room profile.
	ProfileName *string `min:"1" type:"string"`

	// The temperature unit of a room profile.
	TemperatureUnit TemperatureUnit `type:"string" enum:"true"`

	// The timezone of a room profile.
	Timezone *string `min:"1" type:"string"`

	// The wake word of a room profile.
	WakeWord WakeWord `type:"string" enum:"true"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/PutRoomSkillParameterRequest
type PutRoomSkillParameterInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room associated with the room skill parameter. Required.
	RoomArn *string `type:"string"`

	// The updated room skill parameter. Required.
	//
	// RoomSkillParameter is a required field
	RoomSkillParameter *RoomSkillParameter `type:"structure" required:"true"`

	// The ARN of the skill associated with the room skill parameter. Required.
	//
	// SkillId is a required field
	SkillId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/PutRoomSkillParameterResponse
type PutRoomSkillParameterOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ResolveRoomRequest
type ResolveRoomInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the skill that was requested. Required.
	//
	// SkillId is a required field
	SkillId *string `type:"string" required:"true"`

	// The ARN of the user. Required.
	//
	// UserId is a required field
	UserId *string `type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/ResolveRoomResponse
type ResolveRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ARN of the room from which the skill request was invoked.
	RoomArn *string `type:"string"`

	// The name of the room from which the skill request was invoked.
	RoomName *string `min:"1" type:"string"`

	// Response to get the room profile request. Required.
	RoomSkillParameters []RoomSkillParameter `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/RevokeInvitationRequest
type RevokeInvitationInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the enrollment invitation to revoke. Required.
	EnrollmentId *string `type:"string"`

	// The ARN of the user for whom to revoke an enrollment invitation. Required.
	UserArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/RevokeInvitationResponse
type RevokeInvitationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// A room with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Room
type Room struct {
	_ struct{} `type:"structure"`

	// The description of a room.
	Description *string `min:"1" type:"string"`

	// The profile ARN of a room.
	ProfileArn *string `type:"string"`

	// The provider calendar ARN of a room.
	ProviderCalendarId *string `type:"string"`

	// The ARN of a room.
	RoomArn *string `type:"string"`

	// The name of a room.
	RoomName *string `min:"1" type:"string"`
}

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

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

// The data of a room.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/RoomData
type RoomData struct {
	_ struct{} `type:"structure"`

	// The description of a room.
	Description *string `min:"1" type:"string"`

	// The profile ARN of a room.
	ProfileArn *string `type:"string"`

	// The profile name of a room.
	ProfileName *string `min:"1" type:"string"`

	// The provider calendar ARN of a room.
	ProviderCalendarId *string `type:"string"`

	// The ARN of a room.
	RoomArn *string `type:"string"`

	// The name of a room.
	RoomName *string `min:"1" type:"string"`
}

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

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

// A skill parameter associated with a room.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/RoomSkillParameter
type RoomSkillParameter struct {
	_ struct{} `type:"structure"`

	// The parameter key of a room skill parameter. ParameterKey is an enumerated
	// type that only takes “DEFAULT” or “SCOPE” as valid values.
	//
	// ParameterKey is a required field
	ParameterKey *string `min:"1" type:"string" required:"true"`

	// The parameter value of a room skill parameter.
	//
	// ParameterValue is a required field
	ParameterValue *string `min:"1" type:"string" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchAddressBooksRequest
type SearchAddressBooksInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of address books. The supported
	// filter key is AddressBookName.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// only includes results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of address books. The
	// supported sort key is AddressBookName.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchAddressBooksInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchAddressBooksInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchAddressBooksResponse
type SearchAddressBooksOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The address books that meet the specified set of filter criteria, in sort
	// order.
	AddressBooks []AddressBookData `type:"list"`

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The total number of address books returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchContactsRequest
type SearchContactsInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of address books. The supported
	// filter keys are DisplayName, FirstName, LastName, and AddressBookArns.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// only includes results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of contacts. The supported
	// sort keys are DisplayName, FirstName, and LastName.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchContactsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchContactsInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchContactsResponse
type SearchContactsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The contacts that meet the specified set of filter criteria, in sort order.
	Contacts []ContactData `type:"list"`

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The total number of contacts returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchDevicesRequest
type SearchDevicesInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of devices. Supported filter keys
	// are DeviceName, DeviceStatus, DeviceStatusDetailCode, RoomName, DeviceType,
	// DeviceSerialNumber, UnassociatedOnly, and ConnectionStatus (ONLINE and OFFLINE).
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of devices. Supported
	// sort keys are DeviceName, DeviceStatus, RoomName, DeviceType, DeviceSerialNumber,
	// and ConnectionStatus.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchDevicesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchDevicesInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchDevicesResponse
type SearchDevicesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The devices that meet the specified set of filter criteria, in sort order.
	Devices []DeviceData `type:"list"`

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The total number of devices returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchProfilesRequest
type SearchProfilesInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of room profiles. Supported filter
	// keys are ProfileName and Address. Required.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of room profiles. Supported
	// sort keys are ProfileName and Address.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchProfilesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchProfilesInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchProfilesResponse
type SearchProfilesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The profiles that meet the specified set of filter criteria, in sort order.
	Profiles []ProfileData `type:"list"`

	// The total number of room profiles returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchRoomsRequest
type SearchRoomsInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of rooms. The supported filter
	// keys are RoomName and ProfileName.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of rooms. The supported
	// sort keys are RoomName and ProfileName.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchRoomsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchRoomsInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchRoomsResponse
type SearchRoomsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The rooms that meet the specified set of filter criteria, in sort order.
	Rooms []RoomData `type:"list"`

	// The total number of rooms returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchSkillGroupsRequest
type SearchSkillGroupsInput struct {
	_ struct{} `type:"structure"`

	// The filters to use to list a specified set of skill groups. The supported
	// filter key is SkillGroupName.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	// Required.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the specified set of skill groups. The supported
	// sort key is SkillGroupName.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchSkillGroupsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchSkillGroupsInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchSkillGroupsResponse
type SearchSkillGroupsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The skill groups that meet the filter criteria, in sort order.
	SkillGroups []SkillGroupData `type:"list"`

	// The total number of skill groups returned.
	TotalCount *int64 `type:"integer"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchUsersRequest
type SearchUsersInput struct {
	_ struct{} `type:"structure"`

	// The filters to use for listing a specific set of users. Required. Supported
	// filter keys are UserId, FirstName, LastName, Email, and EnrollmentStatus.
	Filters []Filter `type:"list"`

	// The maximum number of results to include in the response. If more results
	// exist than the specified MaxResults value, a token is included in the response
	// so that the remaining results can be retrieved. Required.
	MaxResults *int64 `min:"1" type:"integer"`

	// An optional token returned from a prior request. Use this token for pagination
	// of results from this action. If this parameter is specified, the response
	// includes only results beyond the token, up to the value specified by MaxResults.
	// Required.
	NextToken *string `min:"1" type:"string"`

	// The sort order to use in listing the filtered set of users. Required. Supported
	// sort keys are UserId, FirstName, LastName, Email, and EnrollmentStatus.
	SortCriteria []Sort `type:"list"`
}

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

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

// Validate inspects the fields of the type to determine if they are valid.
func (s *SearchUsersInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SearchUsersInput"}
	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.Filters != nil {
		for i, v := range s.Filters {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(aws.ErrInvalidParams))
			}
		}
	}
	if s.SortCriteria != nil {
		for i, v := range s.SortCriteria {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "SortCriteria", i), err.(aws.ErrInvalidParams))
			}
		}
	}

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SearchUsersResponse
type SearchUsersOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The token returned to indicate that there is more data available.
	NextToken *string `min:"1" type:"string"`

	// The total number of users returned.
	TotalCount *int64 `type:"integer"`

	// The users that meet the specified set of filter criteria, in sort order.
	Users []UserData `type:"list"`
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SendInvitationRequest
type SendInvitationInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the user to whom to send an invitation. Required.
	UserArn *string `type:"string"`
}

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SendInvitationResponse
type SendInvitationOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// A skill group with attributes.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SkillGroup
type SkillGroup struct {
	_ struct{} `type:"structure"`

	// The description of a skill group.
	Description *string `min:"1" type:"string"`

	// The ARN of a skill group.
	SkillGroupArn *string `type:"string"`

	// The name of a skill group.
	SkillGroupName *string `min:"1" type:"string"`
}

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

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

// The attributes of a skill group.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SkillGroupData
type SkillGroupData struct {
	_ struct{} `type:"structure"`

	// The description of a skill group.
	Description *string `min:"1" type:"string"`

	// The skill group ARN of a skill group.
	SkillGroupArn *string `type:"string"`

	// The skill group name of a skill group.
	SkillGroupName *string `min:"1" type:"string"`
}

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

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

// The summary of skills.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/SkillSummary
type SkillSummary struct {
	_ struct{} `type:"structure"`

	// The ARN of the skill summary.
	SkillId *string `type:"string"`

	// The name of the skill.
	SkillName *string `min:"1" type:"string"`

	// Linking support for a skill.
	SupportsLinking *bool `type:"boolean"`
}

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

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

// An object representing a sort criteria.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Sort
type Sort struct {
	_ struct{} `type:"structure"`

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

	// The sort value of a sort object.
	//
	// Value is a required field
	Value SortValue `type:"string" required:"true" enum:"true"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/StartDeviceSyncRequest
type StartDeviceSyncInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the device to sync. Required.
	DeviceArn *string `type:"string"`

	// Request structure to start the device sync. Required.
	//
	// Features is a required field
	Features []Feature `type:"list" required:"true"`

	// The ARN of the room with which the device to sync is associated. Required.
	RoomArn *string `type:"string"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/StartDeviceSyncResponse
type StartDeviceSyncOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// A key-value pair that can be associated with a resource.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/Tag
type Tag struct {
	_ struct{} `type:"structure"`

	// The key of a tag. Tag keys are case-sensitive.
	Key *string `min:"1" type:"string"`

	// The value of a tag. Tag values are case-sensitive and can be null.
	Value *string `type:"string"`
}

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

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

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

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

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

	// The ARN of the resource to which to add metadata tags. Required.
	//
	// Arn is a required field
	Arn *string `type:"string" required:"true"`

	// The tags to be added to the specified resource. Do not provide system tags.
	// Required.
	//
	// Tags is a required field
	Tags []Tag `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/TagResourceResponse
type TagResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

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

	// The ARN of the resource from which to remove metadata tags. Required.
	//
	// Arn is a required field
	Arn *string `type:"string" required:"true"`

	// The tags to be removed from the specified resource. Do not provide system
	// tags. Required.
	//
	// TagKeys is a required field
	TagKeys []string `type:"list" required:"true"`
}

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UntagResourceResponse
type UntagResourceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateAddressBookRequest
type UpdateAddressBookInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the room to update.
	//
	// AddressBookArn is a required field
	AddressBookArn *string `type:"string" required:"true"`

	// The updated description of the room.
	Description *string `min:"1" type:"string"`

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

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateAddressBookResponse
type UpdateAddressBookOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateContactRequest
type UpdateContactInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the contact to update.
	//
	// ContactArn is a required field
	ContactArn *string `type:"string" required:"true"`

	// The updated display name of the contact.
	DisplayName *string `min:"1" type:"string"`

	// The updated first name of the contact.
	FirstName *string `min:"1" type:"string"`

	// The updated last name of the contact.
	LastName *string `min:"1" type:"string"`

	// The updated phone number of the contact.
	PhoneNumber *string `type:"string"`
}

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

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateContactResponse
type UpdateContactOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateDeviceRequest
type UpdateDeviceInput struct {
	_ struct{} `type:"structure"`

	// The ARN of the device to update. Required.
	DeviceArn *string `type:"string"`

	// The updated device name. Required.
	DeviceName *string `min:"2" type:"string"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateDeviceResponse
type UpdateDeviceOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateProfileRequest
type UpdateProfileInput struct {
	_ struct{} `type:"structure"`

	// The updated address for the room profile.
	Address *string `min:"1" type:"string"`

	// The updated distance unit for the room profile.
	DistanceUnit DistanceUnit `type:"string" enum:"true"`

	// The updated maximum volume limit for the room profile.
	MaxVolumeLimit *int64 `type:"integer"`

	// Whether the PSTN setting of the room profile is enabled.
	PSTNEnabled *bool `type:"boolean"`

	// The ARN of the room profile to update. Required.
	ProfileArn *string `type:"string"`

	// The updated name for the room profile.
	ProfileName *string `min:"1" type:"string"`

	// Whether the setup mode of the profile is enabled.
	SetupModeDisabled *bool `type:"boolean"`

	// The updated temperature unit for the room profile.
	TemperatureUnit TemperatureUnit `type:"string" enum:"true"`

	// The updated timezone for the room profile.
	Timezone *string `min:"1" type:"string"`

	// The updated wake word for the room profile.
	WakeWord WakeWord `type:"string" enum:"true"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateProfileResponse
type UpdateProfileOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateRoomRequest
type UpdateRoomInput struct {
	_ struct{} `type:"structure"`

	// The updated description for the room.
	Description *string `min:"1" type:"string"`

	// The updated profile ARN for the room.
	ProfileArn *string `type:"string"`

	// The updated provider calendar ARN for the room.
	ProviderCalendarId *string `type:"string"`

	// The ARN of the room to update.
	RoomArn *string `type:"string"`

	// The updated name for the room.
	RoomName *string `min:"1" type:"string"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateRoomResponse
type UpdateRoomOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateSkillGroupRequest
type UpdateSkillGroupInput struct {
	_ struct{} `type:"structure"`

	// The updated description for the skill group.
	Description *string `min:"1" type:"string"`

	// The ARN of the skill group to update.
	SkillGroupArn *string `type:"string"`

	// The updated name for the skill group.
	SkillGroupName *string `min:"1" type:"string"`
}

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

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

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

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

// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UpdateSkillGroupResponse
type UpdateSkillGroupOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response
}

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

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

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

// Information related to a user.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/alexaforbusiness-2017-11-09/UserData
type UserData struct {
	_ struct{} `type:"structure"`

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

	// The enrollment ARN of a user.
	EnrollmentId *string `type:"string"`

	// The enrollment status of a user.
	EnrollmentStatus EnrollmentStatus `type:"string" enum:"true"`

	// The first name of a user.
	FirstName *string `type:"string"`

	// The last name of a user.
	LastName *string `type:"string"`

	// The ARN of a user.
	UserArn *string `type:"string"`
}

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

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

type ConnectionStatus string

// Enum values for ConnectionStatus
const (
	ConnectionStatusOnline  ConnectionStatus = "ONLINE"
	ConnectionStatusOffline ConnectionStatus = "OFFLINE"
)

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

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

type DeviceEventType string

// Enum values for DeviceEventType
const (
	DeviceEventTypeConnectionStatus DeviceEventType = "CONNECTION_STATUS"
	DeviceEventTypeDeviceStatus     DeviceEventType = "DEVICE_STATUS"
)

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

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

type DeviceStatus string

// Enum values for DeviceStatus
const (
	DeviceStatusReady        DeviceStatus = "READY"
	DeviceStatusPending      DeviceStatus = "PENDING"
	DeviceStatusWasOffline   DeviceStatus = "WAS_OFFLINE"
	DeviceStatusDeregistered DeviceStatus = "DEREGISTERED"
)

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

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

type DeviceStatusDetailCode string

// Enum values for DeviceStatusDetailCode
const (
	DeviceStatusDetailCodeDeviceSoftwareUpdateNeeded DeviceStatusDetailCode = "DEVICE_SOFTWARE_UPDATE_NEEDED"
	DeviceStatusDetailCodeDeviceWasOffline           DeviceStatusDetailCode = "DEVICE_WAS_OFFLINE"
)

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

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

type DistanceUnit string

// Enum values for DistanceUnit
const (
	DistanceUnitMetric   DistanceUnit = "METRIC"
	DistanceUnitImperial DistanceUnit = "IMPERIAL"
)

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

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

type EnrollmentStatus string

// Enum values for EnrollmentStatus
const (
	EnrollmentStatusInitialized    EnrollmentStatus = "INITIALIZED"
	EnrollmentStatusPending        EnrollmentStatus = "PENDING"
	EnrollmentStatusRegistered     EnrollmentStatus = "REGISTERED"
	EnrollmentStatusDisassociating EnrollmentStatus = "DISASSOCIATING"
	EnrollmentStatusDeregistering  EnrollmentStatus = "DEREGISTERING"
)

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

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

type Feature string

// Enum values for Feature
const (
	FeatureBluetooth     Feature = "BLUETOOTH"
	FeatureVolume        Feature = "VOLUME"
	FeatureNotifications Feature = "NOTIFICATIONS"
	FeatureLists         Feature = "LISTS"
	FeatureSkills        Feature = "SKILLS"
	FeatureAll           Feature = "ALL"
)

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

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

type SortValue string

// Enum values for SortValue
const (
	SortValueAsc  SortValue = "ASC"
	SortValueDesc SortValue = "DESC"
)

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

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

type TemperatureUnit string

// Enum values for TemperatureUnit
const (
	TemperatureUnitFahrenheit TemperatureUnit = "FAHRENHEIT"
	TemperatureUnitCelsius    TemperatureUnit = "CELSIUS"
)

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

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

type WakeWord string

// Enum values for WakeWord
const (
	WakeWordAlexa    WakeWord = "ALEXA"
	WakeWordAmazon   WakeWord = "AMAZON"
	WakeWordEcho     WakeWord = "ECHO"
	WakeWordComputer WakeWord = "COMPUTER"
)

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

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