func (c *Glacier) DescribeVaultRequest(input *DescribeVaultInput) DescribeVaultRequest {
	op := &aws.Operation{
		Name:       opDescribeVault,
		HTTPMethod: "GET",
		HTTPPath:   "/{accountId}/vaults/{vaultName}",
	}
	if input == nil {
		input = &DescribeVaultInput{}
	}
	output := &DescribeVaultOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return DescribeVaultRequest{Request: req, Input: input, Copy: c.DescribeVaultRequest}
}
DescribeVaultRequest returns a request value for making API operation for
Amazon Glacier.

This operation returns information about a vault, including the vault's Amazon
Resource Name (ARN), the date the vault was created, the number of archives
it contains, and the total size of all the archives in the vault. The number
of archives and their total size are as of the last inventory generation.
This means that if you add or remove an archive from a vault, and then immediately
use Describe Vault, the change in contents will not be immediately reflected.
If you want to retrieve the latest inventory of the vault, use InitiateJob.
Amazon Glacier generates vault inventories approximately daily. For more
information, see Downloading a Vault Inventory in Amazon Glacier (http://docs.aws.amazon.com/amazonglacier/latest/dev/vault-inventory.html).

An AWS account has full permission to perform all operations (actions). However,
AWS Identity and Access Management (IAM) users don't have any permissions
by default. You must grant them explicit permission to perform specific actions.
For more information, see Access Control Using AWS Identity and Access Management
(IAM) (http://docs.aws.amazon.com/amazonglacier/latest/dev/using-iam-with-amazon-glacier.html).

For conceptual information and underlying REST API, see Retrieving Vault
Metadata in Amazon Glacier (http://docs.aws.amazon.com/amazonglacier/latest/dev/retrieving-vault-info.html)
and Describe Vault  (http://docs.aws.amazon.com/amazonglacier/latest/dev/api-vault-get.html)
in the Amazon Glacier Developer Guide.

// Example sending a request using the DescribeVaultRequest method.
req := client.DescribeVaultRequest(params)
resp, err := req.Send()
if err == nil {
fmt.Println(resp)
}
package glacier
import (
	"fmt"
	"io"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
	"github.com/aws/aws-sdk-go-v2/private/protocol"
	"github.com/aws/aws-sdk-go-v2/private/protocol/restjson"
)
const opAbortMultipartUpload = "AbortMultipartUpload"
type AbortMultipartUploadRequest struct {
	*aws.Request
	Input *AbortMultipartUploadInput
	Copy  func(*AbortMultipartUploadInput) AbortMultipartUploadRequest
}
func (r AbortMultipartUploadRequest) Send() (*AbortMultipartUploadOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*AbortMultipartUploadOutput), nil
}
func (c *Glacier) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) AbortMultipartUploadRequest {
	op := &aws.Operation{
		Name:       opAbortMultipartUpload,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
	}
	if input == nil {
		input = &AbortMultipartUploadInput{}
	}
	output := &AbortMultipartUploadOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return AbortMultipartUploadRequest{Request: req, Input: input, Copy: c.AbortMultipartUploadRequest}
}
const opAbortVaultLock = "AbortVaultLock"
type AbortVaultLockRequest struct {
	*aws.Request
	Input *AbortVaultLockInput
	Copy  func(*AbortVaultLockInput) AbortVaultLockRequest
}
func (r AbortVaultLockRequest) Send() (*AbortVaultLockOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*AbortVaultLockOutput), nil
}
func (c *Glacier) AbortVaultLockRequest(input *AbortVaultLockInput) AbortVaultLockRequest {
	op := &aws.Operation{
		Name:       opAbortVaultLock,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/lock-policy",
	}
	if input == nil {
		input = &AbortVaultLockInput{}
	}
	output := &AbortVaultLockOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return AbortVaultLockRequest{Request: req, Input: input, Copy: c.AbortVaultLockRequest}
}
const opAddTagsToVault = "AddTagsToVault"
type AddTagsToVaultRequest struct {
	*aws.Request
	Input *AddTagsToVaultInput
	Copy  func(*AddTagsToVaultInput) AddTagsToVaultRequest
}
func (r AddTagsToVaultRequest) Send() (*AddTagsToVaultOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*AddTagsToVaultOutput), nil
}
func (c *Glacier) AddTagsToVaultRequest(input *AddTagsToVaultInput) AddTagsToVaultRequest {
	op := &aws.Operation{
		Name:       opAddTagsToVault,
		HTTPMethod: "POST",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/tags?operation=add",
	}
	if input == nil {
		input = &AddTagsToVaultInput{}
	}
	output := &AddTagsToVaultOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return AddTagsToVaultRequest{Request: req, Input: input, Copy: c.AddTagsToVaultRequest}
}
const opCompleteMultipartUpload = "CompleteMultipartUpload"
type CompleteMultipartUploadRequest struct {
	*aws.Request
	Input *CompleteMultipartUploadInput
	Copy  func(*CompleteMultipartUploadInput) CompleteMultipartUploadRequest
}
func (r CompleteMultipartUploadRequest) Send() (*UploadArchiveOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*UploadArchiveOutput), nil
}
func (c *Glacier) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) CompleteMultipartUploadRequest {
	op := &aws.Operation{
		Name:       opCompleteMultipartUpload,
		HTTPMethod: "POST",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
	}
	if input == nil {
		input = &CompleteMultipartUploadInput{}
	}
	output := &UploadArchiveOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return CompleteMultipartUploadRequest{Request: req, Input: input, Copy: c.CompleteMultipartUploadRequest}
}
const opCompleteVaultLock = "CompleteVaultLock"
type CompleteVaultLockRequest struct {
	*aws.Request
	Input *CompleteVaultLockInput
	Copy  func(*CompleteVaultLockInput) CompleteVaultLockRequest
}
func (r CompleteVaultLockRequest) Send() (*CompleteVaultLockOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*CompleteVaultLockOutput), nil
}
func (c *Glacier) CompleteVaultLockRequest(input *CompleteVaultLockInput) CompleteVaultLockRequest {
	op := &aws.Operation{
		Name:       opCompleteVaultLock,
		HTTPMethod: "POST",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/lock-policy/{lockId}",
	}
	if input == nil {
		input = &CompleteVaultLockInput{}
	}
	output := &CompleteVaultLockOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return CompleteVaultLockRequest{Request: req, Input: input, Copy: c.CompleteVaultLockRequest}
}
const opCreateVault = "CreateVault"
type CreateVaultRequest struct {
	*aws.Request
	Input *CreateVaultInput
	Copy  func(*CreateVaultInput) CreateVaultRequest
}
func (r CreateVaultRequest) Send() (*CreateVaultOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*CreateVaultOutput), nil
}
func (c *Glacier) CreateVaultRequest(input *CreateVaultInput) CreateVaultRequest {
	op := &aws.Operation{
		Name:       opCreateVault,
		HTTPMethod: "PUT",
		HTTPPath:   "/{accountId}/vaults/{vaultName}",
	}
	if input == nil {
		input = &CreateVaultInput{}
	}
	output := &CreateVaultOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return CreateVaultRequest{Request: req, Input: input, Copy: c.CreateVaultRequest}
}
const opDeleteArchive = "DeleteArchive"
type DeleteArchiveRequest struct {
	*aws.Request
	Input *DeleteArchiveInput
	Copy  func(*DeleteArchiveInput) DeleteArchiveRequest
}
func (r DeleteArchiveRequest) Send() (*DeleteArchiveOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DeleteArchiveOutput), nil
}
func (c *Glacier) DeleteArchiveRequest(input *DeleteArchiveInput) DeleteArchiveRequest {
	op := &aws.Operation{
		Name:       opDeleteArchive,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/archives/{archiveId}",
	}
	if input == nil {
		input = &DeleteArchiveInput{}
	}
	output := &DeleteArchiveOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return DeleteArchiveRequest{Request: req, Input: input, Copy: c.DeleteArchiveRequest}
}
const opDeleteVault = "DeleteVault"
type DeleteVaultRequest struct {
	*aws.Request
	Input *DeleteVaultInput
	Copy  func(*DeleteVaultInput) DeleteVaultRequest
}
func (r DeleteVaultRequest) Send() (*DeleteVaultOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DeleteVaultOutput), nil
}
func (c *Glacier) DeleteVaultRequest(input *DeleteVaultInput) DeleteVaultRequest {
	op := &aws.Operation{
		Name:       opDeleteVault,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}",
	}
	if input == nil {
		input = &DeleteVaultInput{}
	}
	output := &DeleteVaultOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return DeleteVaultRequest{Request: req, Input: input, Copy: c.DeleteVaultRequest}
}
const opDeleteVaultAccessPolicy = "DeleteVaultAccessPolicy"
type DeleteVaultAccessPolicyRequest struct {
	*aws.Request
	Input *DeleteVaultAccessPolicyInput
	Copy  func(*DeleteVaultAccessPolicyInput) DeleteVaultAccessPolicyRequest
}
func (r DeleteVaultAccessPolicyRequest) Send() (*DeleteVaultAccessPolicyOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DeleteVaultAccessPolicyOutput), nil
}
func (c *Glacier) DeleteVaultAccessPolicyRequest(input *DeleteVaultAccessPolicyInput) DeleteVaultAccessPolicyRequest {
	op := &aws.Operation{
		Name:       opDeleteVaultAccessPolicy,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/access-policy",
	}
	if input == nil {
		input = &DeleteVaultAccessPolicyInput{}
	}
	output := &DeleteVaultAccessPolicyOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return DeleteVaultAccessPolicyRequest{Request: req, Input: input, Copy: c.DeleteVaultAccessPolicyRequest}
}
const opDeleteVaultNotifications = "DeleteVaultNotifications"
type DeleteVaultNotificationsRequest struct {
	*aws.Request
	Input *DeleteVaultNotificationsInput
	Copy  func(*DeleteVaultNotificationsInput) DeleteVaultNotificationsRequest
}
func (r DeleteVaultNotificationsRequest) Send() (*DeleteVaultNotificationsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DeleteVaultNotificationsOutput), nil
}
func (c *Glacier) DeleteVaultNotificationsRequest(input *DeleteVaultNotificationsInput) DeleteVaultNotificationsRequest {
	op := &aws.Operation{
		Name:       opDeleteVaultNotifications,
		HTTPMethod: "DELETE",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/notification-configuration",
	}
	if input == nil {
		input = &DeleteVaultNotificationsInput{}
	}
	output := &DeleteVaultNotificationsOutput{}
	req := c.newRequest(op, input, output)
	req.Handlers.Unmarshal.Remove(restjson.UnmarshalHandler)
	req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler)
	output.responseMetadata = aws.Response{Request: req}
	return DeleteVaultNotificationsRequest{Request: req, Input: input, Copy: c.DeleteVaultNotificationsRequest}
}
const opDescribeJob = "DescribeJob"
type DescribeJobRequest struct {
	*aws.Request
	Input *DescribeJobInput
	Copy  func(*DescribeJobInput) DescribeJobRequest
}
func (r DescribeJobRequest) Send() (*DescribeJobOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DescribeJobOutput), nil
}
func (c *Glacier) DescribeJobRequest(input *DescribeJobInput) DescribeJobRequest {
	op := &aws.Operation{
		Name:       opDescribeJob,
		HTTPMethod: "GET",
		HTTPPath:   "/{accountId}/vaults/{vaultName}/jobs/{jobId}",
	}
	if input == nil {
		input = &DescribeJobInput{}
	}
	output := &DescribeJobOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return DescribeJobRequest{Request: req, Input: input, Copy: c.DescribeJobRequest}
}
const opDescribeVault = "DescribeVault"
type DescribeVaultRequest struct {
	*aws.Request
	Input *DescribeVaultInput
	Copy  func(*DescribeVaultInput) DescribeVaultRequest
}
func (r DescribeVaultRequest) Send() (*DescribeVaultOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*DescribeVaultOutput), nil
}