func (r CompleteVaultLockRequest) Send() (*CompleteVaultLockOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*CompleteVaultLockOutput), nil
}
Send marshals and sends the CompleteVaultLock API request.
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
}