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

This operation downloads the output of the job you initiated using InitiateJob.
Depending on the job type you specified when you initiated the job, the output
will be either the content of an archive or a vault inventory.

You can download all the job output or download a portion of the output by
specifying a byte range. In the case of an archive retrieval job, depending
on the byte range you specify, Amazon Glacier returns the checksum for the
portion of the data. You can compute the checksum on the client and verify
that the values match to ensure the portion you downloaded is the correct
data.

A job ID will not expire for at least 24 hours after Amazon Glacier completes
the job. That a byte range. For both archive and inventory retrieval jobs,
you should verify the downloaded size against the size returned in the headers
from the Get Job Output response.

For archive retrieval jobs, you should also verify that the size is what
you expected. If you download a portion of the output, the expected size
is based on the range of bytes you specified. For example, if you specify
a range of bytes=0-1048575, you should verify your download size is 1,048,576
bytes. If you download an entire archive, the expected size is the size of
the archive when you uploaded it to Amazon Glacier The expected size is also
returned in the headers from the Get Job Output response.

In the case of an archive retrieval job, depending on the byte range you
specify, Amazon Glacier returns the checksum for the portion of the data.
To ensure the portion you downloaded is the correct data, compute the checksum
on the client, verify that the values match, and verify that the size is
what you expected.

A job ID does not expire for at least 24 hours after Amazon Glacier completes
the job. That is, you can download the job output within the 24 hours period
after Amazon Glacier completes the job.

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 the underlying REST API, see Downloading a
Vault Inventory (http://docs.aws.amazon.com/amazonglacier/latest/dev/vault-inventory.html),
Downloading an Archive (http://docs.aws.amazon.com/amazonglacier/latest/dev/downloading-an-archive.html),
and Get Job Output  (http://docs.aws.amazon.com/amazonglacier/latest/dev/api-job-output-get.html)

// Example sending a request using the GetJobOutputRequest method.
req := client.GetJobOutputRequest(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
}
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}
}
const opGetDataRetrievalPolicy = "GetDataRetrievalPolicy"
type GetDataRetrievalPolicyRequest struct {
	*aws.Request
	Input *GetDataRetrievalPolicyInput
	Copy  func(*GetDataRetrievalPolicyInput) GetDataRetrievalPolicyRequest
}
func (r GetDataRetrievalPolicyRequest) Send() (*GetDataRetrievalPolicyOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*GetDataRetrievalPolicyOutput), nil
}
func (c *Glacier) GetDataRetrievalPolicyRequest(input *GetDataRetrievalPolicyInput) GetDataRetrievalPolicyRequest {
	op := &aws.Operation{
		Name:       opGetDataRetrievalPolicy,
		HTTPMethod: "GET",
		HTTPPath:   "/{accountId}/policies/data-retrieval",
	}
	if input == nil {
		input = &GetDataRetrievalPolicyInput{}
	}
	output := &GetDataRetrievalPolicyOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return GetDataRetrievalPolicyRequest{Request: req, Input: input, Copy: c.GetDataRetrievalPolicyRequest}
}
const opGetJobOutput = "GetJobOutput"
type GetJobOutputRequest struct {
	*aws.Request
	Input *GetJobOutputInput
	Copy  func(*GetJobOutputInput) GetJobOutputRequest
}
func (r GetJobOutputRequest) Send() (*GetJobOutputOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*GetJobOutputOutput), nil
}