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}
}
DescribeJobRequest returns a request value for making API operation for
Amazon Glacier.

This operation returns information about a job you previously initiated,
including the job initiation date, the user who initiated the job, the job
status code/message and the Amazon SNS topic to notify after Amazon Glacier
completes the job. For more information about initiating a job, see InitiateJob.

This operation enables you to check the status of your job. However, it is
strongly recommended that you set up an Amazon SNS topic and specify it in
your initiate job request so that Amazon Glacier can notify the topic after
it completes the job.

A job ID will not expire for at least 24 hours 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 more information about using this operation, see the documentation for
the underlying REST API Describe Job (http://docs.aws.amazon.com/amazonglacier/latest/dev/api-describe-job-get.html)
in the Amazon Glacier Developer Guide.

// Example sending a request using the DescribeJobRequest method.
req := client.DescribeJobRequest(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
}