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

This operation aborts the vault locking process if the vault lock is not
in the Locked state. If the vault lock is in the Locked state when this operation
is requested, the operation returns an AccessDeniedException error. Aborting
the vault locking process removes the vault lock policy from the specified
vault.

A vault lock is put into the InProgress state by calling InitiateVaultLock.
A vault lock is put into the Locked state by calling CompleteVaultLock. You
can get the state of a vault lock by calling GetVaultLock. For more information
about the vault locking process, see Amazon Glacier Vault Lock (http://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock.html).
For more information about vault lock policies, see Amazon Glacier Access
Control with Vault Lock Policies (http://docs.aws.amazon.com/amazonglacier/latest/dev/vault-lock-policy.html).

This operation is idempotent. You can successfully invoke this operation
multiple times, if the vault lock is in the InProgress state or if there
is no policy associated with the vault.

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