func (c *IAM) DeleteGroupPolicyRequest(input *DeleteGroupPolicyInput) (req *request.Request, output *DeleteGroupPolicyOutput) {
	op := &request.Operation{
		Name:       opDeleteGroupPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteGroupPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteGroupPolicyOutput{}
	req.Data = output
	return
}
DeleteGroupPolicyRequest generates a request for the DeleteGroupPolicy operation.
package iam
import (
	"time"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
)
const opAddClientIDToOpenIDConnectProvider = "AddClientIDToOpenIDConnectProvider"
func (c *IAM) AddClientIDToOpenIDConnectProviderRequest(input *AddClientIDToOpenIDConnectProviderInput) (req *request.Request, output *AddClientIDToOpenIDConnectProviderOutput) {
	op := &request.Operation{
		Name:       opAddClientIDToOpenIDConnectProvider,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddClientIDToOpenIDConnectProviderInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddClientIDToOpenIDConnectProviderOutput{}
	req.Data = output
	return
}
func (c *IAM) AddClientIDToOpenIDConnectProvider(input *AddClientIDToOpenIDConnectProviderInput) (*AddClientIDToOpenIDConnectProviderOutput, error) {
	req, out := c.AddClientIDToOpenIDConnectProviderRequest(input)
	err := req.Send()
	return out, err
}
const opAddRoleToInstanceProfile = "AddRoleToInstanceProfile"
func (c *IAM) AddRoleToInstanceProfileRequest(input *AddRoleToInstanceProfileInput) (req *request.Request, output *AddRoleToInstanceProfileOutput) {
	op := &request.Operation{
		Name:       opAddRoleToInstanceProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddRoleToInstanceProfileInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddRoleToInstanceProfileOutput{}
	req.Data = output
	return
}
func (c *IAM) AddRoleToInstanceProfile(input *AddRoleToInstanceProfileInput) (*AddRoleToInstanceProfileOutput, error) {
	req, out := c.AddRoleToInstanceProfileRequest(input)
	err := req.Send()
	return out, err
}
const opAddUserToGroup = "AddUserToGroup"
func (c *IAM) AddUserToGroupRequest(input *AddUserToGroupInput) (req *request.Request, output *AddUserToGroupOutput) {
	op := &request.Operation{
		Name:       opAddUserToGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AddUserToGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AddUserToGroupOutput{}
	req.Data = output
	return
}
func (c *IAM) AddUserToGroup(input *AddUserToGroupInput) (*AddUserToGroupOutput, error) {
	req, out := c.AddUserToGroupRequest(input)
	err := req.Send()
	return out, err
}
const opAttachGroupPolicy = "AttachGroupPolicy"
func (c *IAM) AttachGroupPolicyRequest(input *AttachGroupPolicyInput) (req *request.Request, output *AttachGroupPolicyOutput) {
	op := &request.Operation{
		Name:       opAttachGroupPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachGroupPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachGroupPolicyOutput{}
	req.Data = output
	return
}
func (c *IAM) AttachGroupPolicy(input *AttachGroupPolicyInput) (*AttachGroupPolicyOutput, error) {
	req, out := c.AttachGroupPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opAttachRolePolicy = "AttachRolePolicy"
func (c *IAM) AttachRolePolicyRequest(input *AttachRolePolicyInput) (req *request.Request, output *AttachRolePolicyOutput) {
	op := &request.Operation{
		Name:       opAttachRolePolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachRolePolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachRolePolicyOutput{}
	req.Data = output
	return
}
func (c *IAM) AttachRolePolicy(input *AttachRolePolicyInput) (*AttachRolePolicyOutput, error) {
	req, out := c.AttachRolePolicyRequest(input)
	err := req.Send()
	return out, err
}
const opAttachUserPolicy = "AttachUserPolicy"
func (c *IAM) AttachUserPolicyRequest(input *AttachUserPolicyInput) (req *request.Request, output *AttachUserPolicyOutput) {
	op := &request.Operation{
		Name:       opAttachUserPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AttachUserPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &AttachUserPolicyOutput{}
	req.Data = output
	return
}
func (c *IAM) AttachUserPolicy(input *AttachUserPolicyInput) (*AttachUserPolicyOutput, error) {
	req, out := c.AttachUserPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opChangePassword = "ChangePassword"
func (c *IAM) ChangePasswordRequest(input *ChangePasswordInput) (req *request.Request, output *ChangePasswordOutput) {
	op := &request.Operation{
		Name:       opChangePassword,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &ChangePasswordInput{}
	}
	req = c.newRequest(op, input, output)
	output = &ChangePasswordOutput{}
	req.Data = output
	return
}
func (c *IAM) ChangePassword(input *ChangePasswordInput) (*ChangePasswordOutput, error) {
	req, out := c.ChangePasswordRequest(input)
	err := req.Send()
	return out, err
}
const opCreateAccessKey = "CreateAccessKey"
func (c *IAM) CreateAccessKeyRequest(input *CreateAccessKeyInput) (req *request.Request, output *CreateAccessKeyOutput) {
	op := &request.Operation{
		Name:       opCreateAccessKey,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateAccessKeyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateAccessKeyOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateAccessKey(input *CreateAccessKeyInput) (*CreateAccessKeyOutput, error) {
	req, out := c.CreateAccessKeyRequest(input)
	err := req.Send()
	return out, err
}
const opCreateAccountAlias = "CreateAccountAlias"
func (c *IAM) CreateAccountAliasRequest(input *CreateAccountAliasInput) (req *request.Request, output *CreateAccountAliasOutput) {
	op := &request.Operation{
		Name:       opCreateAccountAlias,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateAccountAliasInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateAccountAliasOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateAccountAlias(input *CreateAccountAliasInput) (*CreateAccountAliasOutput, error) {
	req, out := c.CreateAccountAliasRequest(input)
	err := req.Send()
	return out, err
}
const opCreateGroup = "CreateGroup"
func (c *IAM) CreateGroupRequest(input *CreateGroupInput) (req *request.Request, output *CreateGroupOutput) {
	op := &request.Operation{
		Name:       opCreateGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateGroupOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateGroup(input *CreateGroupInput) (*CreateGroupOutput, error) {
	req, out := c.CreateGroupRequest(input)
	err := req.Send()
	return out, err
}
const opCreateInstanceProfile = "CreateInstanceProfile"
func (c *IAM) CreateInstanceProfileRequest(input *CreateInstanceProfileInput) (req *request.Request, output *CreateInstanceProfileOutput) {
	op := &request.Operation{
		Name:       opCreateInstanceProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateInstanceProfileInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateInstanceProfileOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateInstanceProfile(input *CreateInstanceProfileInput) (*CreateInstanceProfileOutput, error) {
	req, out := c.CreateInstanceProfileRequest(input)
	err := req.Send()
	return out, err
}
const opCreateLoginProfile = "CreateLoginProfile"
func (c *IAM) CreateLoginProfileRequest(input *CreateLoginProfileInput) (req *request.Request, output *CreateLoginProfileOutput) {
	op := &request.Operation{
		Name:       opCreateLoginProfile,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateLoginProfileInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateLoginProfileOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateLoginProfile(input *CreateLoginProfileInput) (*CreateLoginProfileOutput, error) {
	req, out := c.CreateLoginProfileRequest(input)
	err := req.Send()
	return out, err
}
const opCreateOpenIDConnectProvider = "CreateOpenIDConnectProvider"
func (c *IAM) CreateOpenIDConnectProviderRequest(input *CreateOpenIDConnectProviderInput) (req *request.Request, output *CreateOpenIDConnectProviderOutput) {
	op := &request.Operation{
		Name:       opCreateOpenIDConnectProvider,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateOpenIDConnectProviderInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateOpenIDConnectProviderOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateOpenIDConnectProvider(input *CreateOpenIDConnectProviderInput) (*CreateOpenIDConnectProviderOutput, error) {
	req, out := c.CreateOpenIDConnectProviderRequest(input)
	err := req.Send()
	return out, err
}
const opCreatePolicy = "CreatePolicy"
func (c *IAM) CreatePolicyRequest(input *CreatePolicyInput) (req *request.Request, output *CreatePolicyOutput) {
	op := &request.Operation{
		Name:       opCreatePolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreatePolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreatePolicyOutput{}
	req.Data = output
	return
}
func (c *IAM) CreatePolicy(input *CreatePolicyInput) (*CreatePolicyOutput, error) {
	req, out := c.CreatePolicyRequest(input)
	err := req.Send()
	return out, err
}
const opCreatePolicyVersion = "CreatePolicyVersion"
func (c *IAM) CreatePolicyVersionRequest(input *CreatePolicyVersionInput) (req *request.Request, output *CreatePolicyVersionOutput) {
	op := &request.Operation{
		Name:       opCreatePolicyVersion,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreatePolicyVersionInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreatePolicyVersionOutput{}
	req.Data = output
	return
}
func (c *IAM) CreatePolicyVersion(input *CreatePolicyVersionInput) (*CreatePolicyVersionOutput, error) {
	req, out := c.CreatePolicyVersionRequest(input)
	err := req.Send()
	return out, err
}
const opCreateRole = "CreateRole"
func (c *IAM) CreateRoleRequest(input *CreateRoleInput) (req *request.Request, output *CreateRoleOutput) {
	op := &request.Operation{
		Name:       opCreateRole,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateRoleInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateRoleOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateRole(input *CreateRoleInput) (*CreateRoleOutput, error) {
	req, out := c.CreateRoleRequest(input)
	err := req.Send()
	return out, err
}
const opCreateSAMLProvider = "CreateSAMLProvider"
func (c *IAM) CreateSAMLProviderRequest(input *CreateSAMLProviderInput) (req *request.Request, output *CreateSAMLProviderOutput) {
	op := &request.Operation{
		Name:       opCreateSAMLProvider,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateSAMLProviderInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateSAMLProviderOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateSAMLProvider(input *CreateSAMLProviderInput) (*CreateSAMLProviderOutput, error) {
	req, out := c.CreateSAMLProviderRequest(input)
	err := req.Send()
	return out, err
}
const opCreateUser = "CreateUser"
func (c *IAM) CreateUserRequest(input *CreateUserInput) (req *request.Request, output *CreateUserOutput) {
	op := &request.Operation{
		Name:       opCreateUser,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateUserInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateUserOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateUser(input *CreateUserInput) (*CreateUserOutput, error) {
	req, out := c.CreateUserRequest(input)
	err := req.Send()
	return out, err
}
const opCreateVirtualMFADevice = "CreateVirtualMFADevice"
func (c *IAM) CreateVirtualMFADeviceRequest(input *CreateVirtualMFADeviceInput) (req *request.Request, output *CreateVirtualMFADeviceOutput) {
	op := &request.Operation{
		Name:       opCreateVirtualMFADevice,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &CreateVirtualMFADeviceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &CreateVirtualMFADeviceOutput{}
	req.Data = output
	return
}
func (c *IAM) CreateVirtualMFADevice(input *CreateVirtualMFADeviceInput) (*CreateVirtualMFADeviceOutput, error) {
	req, out := c.CreateVirtualMFADeviceRequest(input)
	err := req.Send()
	return out, err
}
const opDeactivateMFADevice = "DeactivateMFADevice"
func (c *IAM) DeactivateMFADeviceRequest(input *DeactivateMFADeviceInput) (req *request.Request, output *DeactivateMFADeviceOutput) {
	op := &request.Operation{
		Name:       opDeactivateMFADevice,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeactivateMFADeviceInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeactivateMFADeviceOutput{}
	req.Data = output
	return
}
func (c *IAM) DeactivateMFADevice(input *DeactivateMFADeviceInput) (*DeactivateMFADeviceOutput, error) {
	req, out := c.DeactivateMFADeviceRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteAccessKey = "DeleteAccessKey"
func (c *IAM) DeleteAccessKeyRequest(input *DeleteAccessKeyInput) (req *request.Request, output *DeleteAccessKeyOutput) {
	op := &request.Operation{
		Name:       opDeleteAccessKey,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteAccessKeyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteAccessKeyOutput{}
	req.Data = output
	return
}
func (c *IAM) DeleteAccessKey(input *DeleteAccessKeyInput) (*DeleteAccessKeyOutput, error) {
	req, out := c.DeleteAccessKeyRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteAccountAlias = "DeleteAccountAlias"
func (c *IAM) DeleteAccountAliasRequest(input *DeleteAccountAliasInput) (req *request.Request, output *DeleteAccountAliasOutput) {
	op := &request.Operation{
		Name:       opDeleteAccountAlias,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteAccountAliasInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteAccountAliasOutput{}
	req.Data = output
	return
}
func (c *IAM) DeleteAccountAlias(input *DeleteAccountAliasInput) (*DeleteAccountAliasOutput, error) {
	req, out := c.DeleteAccountAliasRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteAccountPasswordPolicy = "DeleteAccountPasswordPolicy"
func (c *IAM) DeleteAccountPasswordPolicyRequest(input *DeleteAccountPasswordPolicyInput) (req *request.Request, output *DeleteAccountPasswordPolicyOutput) {
	op := &request.Operation{
		Name:       opDeleteAccountPasswordPolicy,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteAccountPasswordPolicyInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteAccountPasswordPolicyOutput{}
	req.Data = output
	return
}
func (c *IAM) DeleteAccountPasswordPolicy(input *DeleteAccountPasswordPolicyInput) (*DeleteAccountPasswordPolicyOutput, error) {
	req, out := c.DeleteAccountPasswordPolicyRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteGroup = "DeleteGroup"
func (c *IAM) DeleteGroupRequest(input *DeleteGroupInput) (req *request.Request, output *DeleteGroupOutput) {
	op := &request.Operation{
		Name:       opDeleteGroup,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &DeleteGroupInput{}
	}
	req = c.newRequest(op, input, output)
	output = &DeleteGroupOutput{}
	req.Data = output
	return
}
func (c *IAM) DeleteGroup(input *DeleteGroupInput) (*DeleteGroupOutput, error) {
	req, out := c.DeleteGroupRequest(input)
	err := req.Send()
	return out, err
}
const opDeleteGroupPolicy = "DeleteGroupPolicy"