versitygw/s3api/controllers/backend_moq_test.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package controllers

import (
	"bufio"
	"context"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
	"github.com/versity/versitygw/backend"
	"github.com/versity/versitygw/s3response"
	"sync"
)

// Ensure, that BackendMock does implement backend.Backend.
// If this is not the case, regenerate this file with moq.
var _ backend.Backend = &BackendMock{}

// BackendMock is a mock implementation of backend.Backend.
//
//	func TestSomethingThatUsesBackend(t *testing.T) {
//
//		// make and configure a mocked backend.Backend
//		mockedBackend := &BackendMock{
//			AbortMultipartUploadFunc: func(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error {
//				panic("mock out the AbortMultipartUpload method")
//			},
//			ChangeBucketOwnerFunc: func(contextMoqParam context.Context, bucket string, owner string) error {
//				panic("mock out the ChangeBucketOwner method")
//			},
//			CompleteMultipartUploadFunc: func(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (s3response.CompleteMultipartUploadResult, string, error) {
//				panic("mock out the CompleteMultipartUpload method")
//			},
//			CopyObjectFunc: func(contextMoqParam context.Context, copyObjectInput s3response.CopyObjectInput) (s3response.CopyObjectOutput, error) {
//				panic("mock out the CopyObject method")
//			},
//			CreateBucketFunc: func(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput, defaultACL []byte) error {
//				panic("mock out the CreateBucket method")
//			},
//			CreateMultipartUploadFunc: func(contextMoqParam context.Context, createMultipartUploadInput s3response.CreateMultipartUploadInput) (s3response.InitiateMultipartUploadResult, error) {
//				panic("mock out the CreateMultipartUpload method")
//			},
//			DeleteBucketFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucket method")
//			},
//			DeleteBucketCorsFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucketCors method")
//			},
//			DeleteBucketOwnershipControlsFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucketOwnershipControls method")
//			},
//			DeleteBucketPolicyFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucketPolicy method")
//			},
//			DeleteBucketTaggingFunc: func(contextMoqParam context.Context, bucket string) error {
//				panic("mock out the DeleteBucketTagging method")
//			},
//			DeleteObjectFunc: func(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
//				panic("mock out the DeleteObject method")
//			},
//			DeleteObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string) error {
//				panic("mock out the DeleteObjectTagging method")
//			},
//			DeleteObjectsFunc: func(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteResult, error) {
//				panic("mock out the DeleteObjects method")
//			},
//			GetBucketAclFunc: func(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error) {
//				panic("mock out the GetBucketAcl method")
//			},
//			GetBucketCorsFunc: func(contextMoqParam context.Context, bucket string) ([]byte, error) {
//				panic("mock out the GetBucketCors method")
//			},
//			GetBucketOwnershipControlsFunc: func(contextMoqParam context.Context, bucket string) (types.ObjectOwnership, error) {
//				panic("mock out the GetBucketOwnershipControls method")
//			},
//			GetBucketPolicyFunc: func(contextMoqParam context.Context, bucket string) ([]byte, error) {
//				panic("mock out the GetBucketPolicy method")
//			},
//			GetBucketTaggingFunc: func(contextMoqParam context.Context, bucket string) (map[string]string, error) {
//				panic("mock out the GetBucketTagging method")
//			},
//			GetBucketVersioningFunc: func(contextMoqParam context.Context, bucket string) (s3response.GetBucketVersioningOutput, error) {
//				panic("mock out the GetBucketVersioning method")
//			},
//			GetObjectFunc: func(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
//				panic("mock out the GetObject method")
//			},
//			GetObjectAclFunc: func(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
//				panic("mock out the GetObjectAcl method")
//			},
//			GetObjectAttributesFunc: func(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (s3response.GetObjectAttributesResponse, error) {
//				panic("mock out the GetObjectAttributes method")
//			},
//			GetObjectLegalHoldFunc: func(contextMoqParam context.Context, bucket string, object string, versionId string) (*bool, error) {
//				panic("mock out the GetObjectLegalHold method")
//			},
//			GetObjectLockConfigurationFunc: func(contextMoqParam context.Context, bucket string) ([]byte, error) {
//				panic("mock out the GetObjectLockConfiguration method")
//			},
//			GetObjectRetentionFunc: func(contextMoqParam context.Context, bucket string, object string, versionId string) ([]byte, error) {
//				panic("mock out the GetObjectRetention method")
//			},
//			GetObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string) (map[string]string, error) {
//				panic("mock out the GetObjectTagging method")
//			},
//			HeadBucketFunc: func(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
//				panic("mock out the HeadBucket method")
//			},
//			HeadObjectFunc: func(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
//				panic("mock out the HeadObject method")
//			},
//			ListBucketsFunc: func(contextMoqParam context.Context, listBucketsInput s3response.ListBucketsInput) (s3response.ListAllMyBucketsResult, error) {
//				panic("mock out the ListBuckets method")
//			},
//			ListBucketsAndOwnersFunc: func(contextMoqParam context.Context) ([]s3response.Bucket, error) {
//				panic("mock out the ListBucketsAndOwners method")
//			},
//			ListMultipartUploadsFunc: func(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
//				panic("mock out the ListMultipartUploads method")
//			},
//			ListObjectVersionsFunc: func(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (s3response.ListVersionsResult, error) {
//				panic("mock out the ListObjectVersions method")
//			},
//			ListObjectsFunc: func(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (s3response.ListObjectsResult, error) {
//				panic("mock out the ListObjects method")
//			},
//			ListObjectsV2Func: func(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (s3response.ListObjectsV2Result, error) {
//				panic("mock out the ListObjectsV2 method")
//			},
//			ListPartsFunc: func(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error) {
//				panic("mock out the ListParts method")
//			},
//			PutBucketAclFunc: func(contextMoqParam context.Context, bucket string, data []byte) error {
//				panic("mock out the PutBucketAcl method")
//			},
//			PutBucketCorsFunc: func(contextMoqParam context.Context, bytes []byte) error {
//				panic("mock out the PutBucketCors method")
//			},
//			PutBucketOwnershipControlsFunc: func(contextMoqParam context.Context, bucket string, ownership types.ObjectOwnership) error {
//				panic("mock out the PutBucketOwnershipControls method")
//			},
//			PutBucketPolicyFunc: func(contextMoqParam context.Context, bucket string, policy []byte) error {
//				panic("mock out the PutBucketPolicy method")
//			},
//			PutBucketTaggingFunc: func(contextMoqParam context.Context, bucket string, tags map[string]string) error {
//				panic("mock out the PutBucketTagging method")
//			},
//			PutBucketVersioningFunc: func(contextMoqParam context.Context, bucket string, status types.BucketVersioningStatus) error {
//				panic("mock out the PutBucketVersioning method")
//			},
//			PutObjectFunc: func(contextMoqParam context.Context, putObjectInput s3response.PutObjectInput) (s3response.PutObjectOutput, error) {
//				panic("mock out the PutObject method")
//			},
//			PutObjectAclFunc: func(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error {
//				panic("mock out the PutObjectAcl method")
//			},
//			PutObjectLegalHoldFunc: func(contextMoqParam context.Context, bucket string, object string, versionId string, status bool) error {
//				panic("mock out the PutObjectLegalHold method")
//			},
//			PutObjectLockConfigurationFunc: func(contextMoqParam context.Context, bucket string, config []byte) error {
//				panic("mock out the PutObjectLockConfiguration method")
//			},
//			PutObjectRetentionFunc: func(contextMoqParam context.Context, bucket string, object string, versionId string, bypass bool, retention []byte) error {
//				panic("mock out the PutObjectRetention method")
//			},
//			PutObjectTaggingFunc: func(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
//				panic("mock out the PutObjectTagging method")
//			},
//			RestoreObjectFunc: func(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error {
//				panic("mock out the RestoreObject method")
//			},
//			SelectObjectContentFunc: func(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer) {
//				panic("mock out the SelectObjectContent method")
//			},
//			ShutdownFunc: func()  {
//				panic("mock out the Shutdown method")
//			},
//			StringFunc: func() string {
//				panic("mock out the String method")
//			},
//			UploadPartFunc: func(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
//				panic("mock out the UploadPart method")
//			},
//			UploadPartCopyFunc: func(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyPartResult, error) {
//				panic("mock out the UploadPartCopy method")
//			},
//		}
//
//		// use mockedBackend in code that requires backend.Backend
//		// and then make assertions.
//
//	}
type BackendMock struct {
	// AbortMultipartUploadFunc mocks the AbortMultipartUpload method.
	AbortMultipartUploadFunc func(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error

	// ChangeBucketOwnerFunc mocks the ChangeBucketOwner method.
	ChangeBucketOwnerFunc func(contextMoqParam context.Context, bucket string, owner string) error

	// CompleteMultipartUploadFunc mocks the CompleteMultipartUpload method.
	CompleteMultipartUploadFunc func(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (s3response.CompleteMultipartUploadResult, string, error)

	// CopyObjectFunc mocks the CopyObject method.
	CopyObjectFunc func(contextMoqParam context.Context, copyObjectInput s3response.CopyObjectInput) (s3response.CopyObjectOutput, error)

	// CreateBucketFunc mocks the CreateBucket method.
	CreateBucketFunc func(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput, defaultACL []byte) error

	// CreateMultipartUploadFunc mocks the CreateMultipartUpload method.
	CreateMultipartUploadFunc func(contextMoqParam context.Context, createMultipartUploadInput s3response.CreateMultipartUploadInput) (s3response.InitiateMultipartUploadResult, error)

	// DeleteBucketFunc mocks the DeleteBucket method.
	DeleteBucketFunc func(contextMoqParam context.Context, bucket string) error

	// DeleteBucketCorsFunc mocks the DeleteBucketCors method.
	DeleteBucketCorsFunc func(contextMoqParam context.Context, bucket string) error

	// DeleteBucketOwnershipControlsFunc mocks the DeleteBucketOwnershipControls method.
	DeleteBucketOwnershipControlsFunc func(contextMoqParam context.Context, bucket string) error

	// DeleteBucketPolicyFunc mocks the DeleteBucketPolicy method.
	DeleteBucketPolicyFunc func(contextMoqParam context.Context, bucket string) error

	// DeleteBucketTaggingFunc mocks the DeleteBucketTagging method.
	DeleteBucketTaggingFunc func(contextMoqParam context.Context, bucket string) error

	// DeleteObjectFunc mocks the DeleteObject method.
	DeleteObjectFunc func(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)

	// DeleteObjectTaggingFunc mocks the DeleteObjectTagging method.
	DeleteObjectTaggingFunc func(contextMoqParam context.Context, bucket string, object string) error

	// DeleteObjectsFunc mocks the DeleteObjects method.
	DeleteObjectsFunc func(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteResult, error)

	// GetBucketAclFunc mocks the GetBucketAcl method.
	GetBucketAclFunc func(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error)

	// GetBucketCorsFunc mocks the GetBucketCors method.
	GetBucketCorsFunc func(contextMoqParam context.Context, bucket string) ([]byte, error)

	// GetBucketOwnershipControlsFunc mocks the GetBucketOwnershipControls method.
	GetBucketOwnershipControlsFunc func(contextMoqParam context.Context, bucket string) (types.ObjectOwnership, error)

	// GetBucketPolicyFunc mocks the GetBucketPolicy method.
	GetBucketPolicyFunc func(contextMoqParam context.Context, bucket string) ([]byte, error)

	// GetBucketTaggingFunc mocks the GetBucketTagging method.
	GetBucketTaggingFunc func(contextMoqParam context.Context, bucket string) (map[string]string, error)

	// GetBucketVersioningFunc mocks the GetBucketVersioning method.
	GetBucketVersioningFunc func(contextMoqParam context.Context, bucket string) (s3response.GetBucketVersioningOutput, error)

	// GetObjectFunc mocks the GetObject method.
	GetObjectFunc func(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput) (*s3.GetObjectOutput, error)

	// GetObjectAclFunc mocks the GetObjectAcl method.
	GetObjectAclFunc func(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)

	// GetObjectAttributesFunc mocks the GetObjectAttributes method.
	GetObjectAttributesFunc func(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (s3response.GetObjectAttributesResponse, error)

	// GetObjectLegalHoldFunc mocks the GetObjectLegalHold method.
	GetObjectLegalHoldFunc func(contextMoqParam context.Context, bucket string, object string, versionId string) (*bool, error)

	// GetObjectLockConfigurationFunc mocks the GetObjectLockConfiguration method.
	GetObjectLockConfigurationFunc func(contextMoqParam context.Context, bucket string) ([]byte, error)

	// GetObjectRetentionFunc mocks the GetObjectRetention method.
	GetObjectRetentionFunc func(contextMoqParam context.Context, bucket string, object string, versionId string) ([]byte, error)

	// GetObjectTaggingFunc mocks the GetObjectTagging method.
	GetObjectTaggingFunc func(contextMoqParam context.Context, bucket string, object string) (map[string]string, error)

	// HeadBucketFunc mocks the HeadBucket method.
	HeadBucketFunc func(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error)

	// HeadObjectFunc mocks the HeadObject method.
	HeadObjectFunc func(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error)

	// ListBucketsFunc mocks the ListBuckets method.
	ListBucketsFunc func(contextMoqParam context.Context, listBucketsInput s3response.ListBucketsInput) (s3response.ListAllMyBucketsResult, error)

	// ListBucketsAndOwnersFunc mocks the ListBucketsAndOwners method.
	ListBucketsAndOwnersFunc func(contextMoqParam context.Context) ([]s3response.Bucket, error)

	// ListMultipartUploadsFunc mocks the ListMultipartUploads method.
	ListMultipartUploadsFunc func(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error)

	// ListObjectVersionsFunc mocks the ListObjectVersions method.
	ListObjectVersionsFunc func(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (s3response.ListVersionsResult, error)

	// ListObjectsFunc mocks the ListObjects method.
	ListObjectsFunc func(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (s3response.ListObjectsResult, error)

	// ListObjectsV2Func mocks the ListObjectsV2 method.
	ListObjectsV2Func func(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (s3response.ListObjectsV2Result, error)

	// ListPartsFunc mocks the ListParts method.
	ListPartsFunc func(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error)

	// PutBucketAclFunc mocks the PutBucketAcl method.
	PutBucketAclFunc func(contextMoqParam context.Context, bucket string, data []byte) error

	// PutBucketCorsFunc mocks the PutBucketCors method.
	PutBucketCorsFunc func(contextMoqParam context.Context, bytes []byte) error

	// PutBucketOwnershipControlsFunc mocks the PutBucketOwnershipControls method.
	PutBucketOwnershipControlsFunc func(contextMoqParam context.Context, bucket string, ownership types.ObjectOwnership) error

	// PutBucketPolicyFunc mocks the PutBucketPolicy method.
	PutBucketPolicyFunc func(contextMoqParam context.Context, bucket string, policy []byte) error

	// PutBucketTaggingFunc mocks the PutBucketTagging method.
	PutBucketTaggingFunc func(contextMoqParam context.Context, bucket string, tags map[string]string) error

	// PutBucketVersioningFunc mocks the PutBucketVersioning method.
	PutBucketVersioningFunc func(contextMoqParam context.Context, bucket string, status types.BucketVersioningStatus) error

	// PutObjectFunc mocks the PutObject method.
	PutObjectFunc func(contextMoqParam context.Context, putObjectInput s3response.PutObjectInput) (s3response.PutObjectOutput, error)

	// PutObjectAclFunc mocks the PutObjectAcl method.
	PutObjectAclFunc func(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error

	// PutObjectLegalHoldFunc mocks the PutObjectLegalHold method.
	PutObjectLegalHoldFunc func(contextMoqParam context.Context, bucket string, object string, versionId string, status bool) error

	// PutObjectLockConfigurationFunc mocks the PutObjectLockConfiguration method.
	PutObjectLockConfigurationFunc func(contextMoqParam context.Context, bucket string, config []byte) error

	// PutObjectRetentionFunc mocks the PutObjectRetention method.
	PutObjectRetentionFunc func(contextMoqParam context.Context, bucket string, object string, versionId string, bypass bool, retention []byte) error

	// PutObjectTaggingFunc mocks the PutObjectTagging method.
	PutObjectTaggingFunc func(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error

	// RestoreObjectFunc mocks the RestoreObject method.
	RestoreObjectFunc func(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error

	// SelectObjectContentFunc mocks the SelectObjectContent method.
	SelectObjectContentFunc func(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer)

	// ShutdownFunc mocks the Shutdown method.
	ShutdownFunc func()

	// StringFunc mocks the String method.
	StringFunc func() string

	// UploadPartFunc mocks the UploadPart method.
	UploadPartFunc func(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (*s3.UploadPartOutput, error)

	// UploadPartCopyFunc mocks the UploadPartCopy method.
	UploadPartCopyFunc func(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyPartResult, error)

	// calls tracks calls to the methods.
	calls struct {
		// AbortMultipartUpload holds details about calls to the AbortMultipartUpload method.
		AbortMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// AbortMultipartUploadInput is the abortMultipartUploadInput argument value.
			AbortMultipartUploadInput *s3.AbortMultipartUploadInput
		}
		// ChangeBucketOwner holds details about calls to the ChangeBucketOwner method.
		ChangeBucketOwner []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Owner is the owner argument value.
			Owner string
		}
		// CompleteMultipartUpload holds details about calls to the CompleteMultipartUpload method.
		CompleteMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CompleteMultipartUploadInput is the completeMultipartUploadInput argument value.
			CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
		}
		// CopyObject holds details about calls to the CopyObject method.
		CopyObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CopyObjectInput is the copyObjectInput argument value.
			CopyObjectInput s3response.CopyObjectInput
		}
		// CreateBucket holds details about calls to the CreateBucket method.
		CreateBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CreateBucketInput is the createBucketInput argument value.
			CreateBucketInput *s3.CreateBucketInput
			// DefaultACL is the defaultACL argument value.
			DefaultACL []byte
		}
		// CreateMultipartUpload holds details about calls to the CreateMultipartUpload method.
		CreateMultipartUpload []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// CreateMultipartUploadInput is the createMultipartUploadInput argument value.
			CreateMultipartUploadInput s3response.CreateMultipartUploadInput
		}
		// DeleteBucket holds details about calls to the DeleteBucket method.
		DeleteBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// DeleteBucketCors holds details about calls to the DeleteBucketCors method.
		DeleteBucketCors []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// DeleteBucketOwnershipControls holds details about calls to the DeleteBucketOwnershipControls method.
		DeleteBucketOwnershipControls []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// DeleteBucketPolicy holds details about calls to the DeleteBucketPolicy method.
		DeleteBucketPolicy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// DeleteBucketTagging holds details about calls to the DeleteBucketTagging method.
		DeleteBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// DeleteObject holds details about calls to the DeleteObject method.
		DeleteObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// DeleteObjectInput is the deleteObjectInput argument value.
			DeleteObjectInput *s3.DeleteObjectInput
		}
		// DeleteObjectTagging holds details about calls to the DeleteObjectTagging method.
		DeleteObjectTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
		}
		// DeleteObjects holds details about calls to the DeleteObjects method.
		DeleteObjects []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// DeleteObjectsInput is the deleteObjectsInput argument value.
			DeleteObjectsInput *s3.DeleteObjectsInput
		}
		// GetBucketAcl holds details about calls to the GetBucketAcl method.
		GetBucketAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetBucketAclInput is the getBucketAclInput argument value.
			GetBucketAclInput *s3.GetBucketAclInput
		}
		// GetBucketCors holds details about calls to the GetBucketCors method.
		GetBucketCors []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketOwnershipControls holds details about calls to the GetBucketOwnershipControls method.
		GetBucketOwnershipControls []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketPolicy holds details about calls to the GetBucketPolicy method.
		GetBucketPolicy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketTagging holds details about calls to the GetBucketTagging method.
		GetBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetBucketVersioning holds details about calls to the GetBucketVersioning method.
		GetBucketVersioning []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetObject holds details about calls to the GetObject method.
		GetObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectInput is the getObjectInput argument value.
			GetObjectInput *s3.GetObjectInput
		}
		// GetObjectAcl holds details about calls to the GetObjectAcl method.
		GetObjectAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectAclInput is the getObjectAclInput argument value.
			GetObjectAclInput *s3.GetObjectAclInput
		}
		// GetObjectAttributes holds details about calls to the GetObjectAttributes method.
		GetObjectAttributes []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetObjectAttributesInput is the getObjectAttributesInput argument value.
			GetObjectAttributesInput *s3.GetObjectAttributesInput
		}
		// GetObjectLegalHold holds details about calls to the GetObjectLegalHold method.
		GetObjectLegalHold []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// VersionId is the versionId argument value.
			VersionId string
		}
		// GetObjectLockConfiguration holds details about calls to the GetObjectLockConfiguration method.
		GetObjectLockConfiguration []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
		}
		// GetObjectRetention holds details about calls to the GetObjectRetention method.
		GetObjectRetention []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// VersionId is the versionId argument value.
			VersionId string
		}
		// GetObjectTagging holds details about calls to the GetObjectTagging method.
		GetObjectTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
		}
		// HeadBucket holds details about calls to the HeadBucket method.
		HeadBucket []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// HeadBucketInput is the headBucketInput argument value.
			HeadBucketInput *s3.HeadBucketInput
		}
		// HeadObject holds details about calls to the HeadObject method.
		HeadObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// HeadObjectInput is the headObjectInput argument value.
			HeadObjectInput *s3.HeadObjectInput
		}
		// ListBuckets holds details about calls to the ListBuckets method.
		ListBuckets []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListBucketsInput is the listBucketsInput argument value.
			ListBucketsInput s3response.ListBucketsInput
		}
		// ListBucketsAndOwners holds details about calls to the ListBucketsAndOwners method.
		ListBucketsAndOwners []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
		}
		// ListMultipartUploads holds details about calls to the ListMultipartUploads method.
		ListMultipartUploads []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListMultipartUploadsInput is the listMultipartUploadsInput argument value.
			ListMultipartUploadsInput *s3.ListMultipartUploadsInput
		}
		// ListObjectVersions holds details about calls to the ListObjectVersions method.
		ListObjectVersions []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectVersionsInput is the listObjectVersionsInput argument value.
			ListObjectVersionsInput *s3.ListObjectVersionsInput
		}
		// ListObjects holds details about calls to the ListObjects method.
		ListObjects []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectsInput is the listObjectsInput argument value.
			ListObjectsInput *s3.ListObjectsInput
		}
		// ListObjectsV2 holds details about calls to the ListObjectsV2 method.
		ListObjectsV2 []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListObjectsV2Input is the listObjectsV2Input argument value.
			ListObjectsV2Input *s3.ListObjectsV2Input
		}
		// ListParts holds details about calls to the ListParts method.
		ListParts []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// ListPartsInput is the listPartsInput argument value.
			ListPartsInput *s3.ListPartsInput
		}
		// PutBucketAcl holds details about calls to the PutBucketAcl method.
		PutBucketAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Data is the data argument value.
			Data []byte
		}
		// PutBucketCors holds details about calls to the PutBucketCors method.
		PutBucketCors []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bytes is the bytes argument value.
			Bytes []byte
		}
		// PutBucketOwnershipControls holds details about calls to the PutBucketOwnershipControls method.
		PutBucketOwnershipControls []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Ownership is the ownership argument value.
			Ownership types.ObjectOwnership
		}
		// PutBucketPolicy holds details about calls to the PutBucketPolicy method.
		PutBucketPolicy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Policy is the policy argument value.
			Policy []byte
		}
		// PutBucketTagging holds details about calls to the PutBucketTagging method.
		PutBucketTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Tags is the tags argument value.
			Tags map[string]string
		}
		// PutBucketVersioning holds details about calls to the PutBucketVersioning method.
		PutBucketVersioning []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Status is the status argument value.
			Status types.BucketVersioningStatus
		}
		// PutObject holds details about calls to the PutObject method.
		PutObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// PutObjectInput is the putObjectInput argument value.
			PutObjectInput s3response.PutObjectInput
		}
		// PutObjectAcl holds details about calls to the PutObjectAcl method.
		PutObjectAcl []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// PutObjectAclInput is the putObjectAclInput argument value.
			PutObjectAclInput *s3.PutObjectAclInput
		}
		// PutObjectLegalHold holds details about calls to the PutObjectLegalHold method.
		PutObjectLegalHold []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// VersionId is the versionId argument value.
			VersionId string
			// Status is the status argument value.
			Status bool
		}
		// PutObjectLockConfiguration holds details about calls to the PutObjectLockConfiguration method.
		PutObjectLockConfiguration []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Config is the config argument value.
			Config []byte
		}
		// PutObjectRetention holds details about calls to the PutObjectRetention method.
		PutObjectRetention []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// VersionId is the versionId argument value.
			VersionId string
			// Bypass is the bypass argument value.
			Bypass bool
			// Retention is the retention argument value.
			Retention []byte
		}
		// PutObjectTagging holds details about calls to the PutObjectTagging method.
		PutObjectTagging []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// Bucket is the bucket argument value.
			Bucket string
			// Object is the object argument value.
			Object string
			// Tags is the tags argument value.
			Tags map[string]string
		}
		// RestoreObject holds details about calls to the RestoreObject method.
		RestoreObject []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// RestoreObjectInput is the restoreObjectInput argument value.
			RestoreObjectInput *s3.RestoreObjectInput
		}
		// SelectObjectContent holds details about calls to the SelectObjectContent method.
		SelectObjectContent []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Input is the input argument value.
			Input *s3.SelectObjectContentInput
		}
		// Shutdown holds details about calls to the Shutdown method.
		Shutdown []struct {
		}
		// String holds details about calls to the String method.
		String []struct {
		}
		// UploadPart holds details about calls to the UploadPart method.
		UploadPart []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// UploadPartInput is the uploadPartInput argument value.
			UploadPartInput *s3.UploadPartInput
		}
		// UploadPartCopy holds details about calls to the UploadPartCopy method.
		UploadPartCopy []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// UploadPartCopyInput is the uploadPartCopyInput argument value.
			UploadPartCopyInput *s3.UploadPartCopyInput
		}
	}
	lockAbortMultipartUpload          sync.RWMutex
	lockChangeBucketOwner             sync.RWMutex
	lockCompleteMultipartUpload       sync.RWMutex
	lockCopyObject                    sync.RWMutex
	lockCreateBucket                  sync.RWMutex
	lockCreateMultipartUpload         sync.RWMutex
	lockDeleteBucket                  sync.RWMutex
	lockDeleteBucketCors              sync.RWMutex
	lockDeleteBucketOwnershipControls sync.RWMutex
	lockDeleteBucketPolicy            sync.RWMutex
	lockDeleteBucketTagging           sync.RWMutex
	lockDeleteObject                  sync.RWMutex
	lockDeleteObjectTagging           sync.RWMutex
	lockDeleteObjects                 sync.RWMutex
	lockGetBucketAcl                  sync.RWMutex
	lockGetBucketCors                 sync.RWMutex
	lockGetBucketOwnershipControls    sync.RWMutex
	lockGetBucketPolicy               sync.RWMutex
	lockGetBucketTagging              sync.RWMutex
	lockGetBucketVersioning           sync.RWMutex
	lockGetObject                     sync.RWMutex
	lockGetObjectAcl                  sync.RWMutex
	lockGetObjectAttributes           sync.RWMutex
	lockGetObjectLegalHold            sync.RWMutex
	lockGetObjectLockConfiguration    sync.RWMutex
	lockGetObjectRetention            sync.RWMutex
	lockGetObjectTagging              sync.RWMutex
	lockHeadBucket                    sync.RWMutex
	lockHeadObject                    sync.RWMutex
	lockListBuckets                   sync.RWMutex
	lockListBucketsAndOwners          sync.RWMutex
	lockListMultipartUploads          sync.RWMutex
	lockListObjectVersions            sync.RWMutex
	lockListObjects                   sync.RWMutex
	lockListObjectsV2                 sync.RWMutex
	lockListParts                     sync.RWMutex
	lockPutBucketAcl                  sync.RWMutex
	lockPutBucketCors                 sync.RWMutex
	lockPutBucketOwnershipControls    sync.RWMutex
	lockPutBucketPolicy               sync.RWMutex
	lockPutBucketTagging              sync.RWMutex
	lockPutBucketVersioning           sync.RWMutex
	lockPutObject                     sync.RWMutex
	lockPutObjectAcl                  sync.RWMutex
	lockPutObjectLegalHold            sync.RWMutex
	lockPutObjectLockConfiguration    sync.RWMutex
	lockPutObjectRetention            sync.RWMutex
	lockPutObjectTagging              sync.RWMutex
	lockRestoreObject                 sync.RWMutex
	lockSelectObjectContent           sync.RWMutex
	lockShutdown                      sync.RWMutex
	lockString                        sync.RWMutex
	lockUploadPart                    sync.RWMutex
	lockUploadPartCopy                sync.RWMutex
}

// AbortMultipartUpload calls AbortMultipartUploadFunc.
func (mock *BackendMock) AbortMultipartUpload(contextMoqParam context.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput) error {
	if mock.AbortMultipartUploadFunc == nil {
		panic("BackendMock.AbortMultipartUploadFunc: method is nil but Backend.AbortMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam           context.Context
		AbortMultipartUploadInput *s3.AbortMultipartUploadInput
	}{
		ContextMoqParam:           contextMoqParam,
		AbortMultipartUploadInput: abortMultipartUploadInput,
	}
	mock.lockAbortMultipartUpload.Lock()
	mock.calls.AbortMultipartUpload = append(mock.calls.AbortMultipartUpload, callInfo)
	mock.lockAbortMultipartUpload.Unlock()
	return mock.AbortMultipartUploadFunc(contextMoqParam, abortMultipartUploadInput)
}

// AbortMultipartUploadCalls gets all the calls that were made to AbortMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.AbortMultipartUploadCalls())
func (mock *BackendMock) AbortMultipartUploadCalls() []struct {
	ContextMoqParam           context.Context
	AbortMultipartUploadInput *s3.AbortMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam           context.Context
		AbortMultipartUploadInput *s3.AbortMultipartUploadInput
	}
	mock.lockAbortMultipartUpload.RLock()
	calls = mock.calls.AbortMultipartUpload
	mock.lockAbortMultipartUpload.RUnlock()
	return calls
}

// ChangeBucketOwner calls ChangeBucketOwnerFunc.
func (mock *BackendMock) ChangeBucketOwner(contextMoqParam context.Context, bucket string, owner string) error {
	if mock.ChangeBucketOwnerFunc == nil {
		panic("BackendMock.ChangeBucketOwnerFunc: method is nil but Backend.ChangeBucketOwner was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Owner           string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Owner:           owner,
	}
	mock.lockChangeBucketOwner.Lock()
	mock.calls.ChangeBucketOwner = append(mock.calls.ChangeBucketOwner, callInfo)
	mock.lockChangeBucketOwner.Unlock()
	return mock.ChangeBucketOwnerFunc(contextMoqParam, bucket, owner)
}

// ChangeBucketOwnerCalls gets all the calls that were made to ChangeBucketOwner.
// Check the length with:
//
//	len(mockedBackend.ChangeBucketOwnerCalls())
func (mock *BackendMock) ChangeBucketOwnerCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Owner           string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Owner           string
	}
	mock.lockChangeBucketOwner.RLock()
	calls = mock.calls.ChangeBucketOwner
	mock.lockChangeBucketOwner.RUnlock()
	return calls
}

// CompleteMultipartUpload calls CompleteMultipartUploadFunc.
func (mock *BackendMock) CompleteMultipartUpload(contextMoqParam context.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (s3response.CompleteMultipartUploadResult, string, error) {
	if mock.CompleteMultipartUploadFunc == nil {
		panic("BackendMock.CompleteMultipartUploadFunc: method is nil but Backend.CompleteMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam              context.Context
		CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
	}{
		ContextMoqParam:              contextMoqParam,
		CompleteMultipartUploadInput: completeMultipartUploadInput,
	}
	mock.lockCompleteMultipartUpload.Lock()
	mock.calls.CompleteMultipartUpload = append(mock.calls.CompleteMultipartUpload, callInfo)
	mock.lockCompleteMultipartUpload.Unlock()
	return mock.CompleteMultipartUploadFunc(contextMoqParam, completeMultipartUploadInput)
}

// CompleteMultipartUploadCalls gets all the calls that were made to CompleteMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.CompleteMultipartUploadCalls())
func (mock *BackendMock) CompleteMultipartUploadCalls() []struct {
	ContextMoqParam              context.Context
	CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam              context.Context
		CompleteMultipartUploadInput *s3.CompleteMultipartUploadInput
	}
	mock.lockCompleteMultipartUpload.RLock()
	calls = mock.calls.CompleteMultipartUpload
	mock.lockCompleteMultipartUpload.RUnlock()
	return calls
}

// CopyObject calls CopyObjectFunc.
func (mock *BackendMock) CopyObject(contextMoqParam context.Context, copyObjectInput s3response.CopyObjectInput) (s3response.CopyObjectOutput, error) {
	if mock.CopyObjectFunc == nil {
		panic("BackendMock.CopyObjectFunc: method is nil but Backend.CopyObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		CopyObjectInput s3response.CopyObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		CopyObjectInput: copyObjectInput,
	}
	mock.lockCopyObject.Lock()
	mock.calls.CopyObject = append(mock.calls.CopyObject, callInfo)
	mock.lockCopyObject.Unlock()
	return mock.CopyObjectFunc(contextMoqParam, copyObjectInput)
}

// CopyObjectCalls gets all the calls that were made to CopyObject.
// Check the length with:
//
//	len(mockedBackend.CopyObjectCalls())
func (mock *BackendMock) CopyObjectCalls() []struct {
	ContextMoqParam context.Context
	CopyObjectInput s3response.CopyObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		CopyObjectInput s3response.CopyObjectInput
	}
	mock.lockCopyObject.RLock()
	calls = mock.calls.CopyObject
	mock.lockCopyObject.RUnlock()
	return calls
}

// CreateBucket calls CreateBucketFunc.
func (mock *BackendMock) CreateBucket(contextMoqParam context.Context, createBucketInput *s3.CreateBucketInput, defaultACL []byte) error {
	if mock.CreateBucketFunc == nil {
		panic("BackendMock.CreateBucketFunc: method is nil but Backend.CreateBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		CreateBucketInput *s3.CreateBucketInput
		DefaultACL        []byte
	}{
		ContextMoqParam:   contextMoqParam,
		CreateBucketInput: createBucketInput,
		DefaultACL:        defaultACL,
	}
	mock.lockCreateBucket.Lock()
	mock.calls.CreateBucket = append(mock.calls.CreateBucket, callInfo)
	mock.lockCreateBucket.Unlock()
	return mock.CreateBucketFunc(contextMoqParam, createBucketInput, defaultACL)
}

// CreateBucketCalls gets all the calls that were made to CreateBucket.
// Check the length with:
//
//	len(mockedBackend.CreateBucketCalls())
func (mock *BackendMock) CreateBucketCalls() []struct {
	ContextMoqParam   context.Context
	CreateBucketInput *s3.CreateBucketInput
	DefaultACL        []byte
} {
	var calls []struct {
		ContextMoqParam   context.Context
		CreateBucketInput *s3.CreateBucketInput
		DefaultACL        []byte
	}
	mock.lockCreateBucket.RLock()
	calls = mock.calls.CreateBucket
	mock.lockCreateBucket.RUnlock()
	return calls
}

// CreateMultipartUpload calls CreateMultipartUploadFunc.
func (mock *BackendMock) CreateMultipartUpload(contextMoqParam context.Context, createMultipartUploadInput s3response.CreateMultipartUploadInput) (s3response.InitiateMultipartUploadResult, error) {
	if mock.CreateMultipartUploadFunc == nil {
		panic("BackendMock.CreateMultipartUploadFunc: method is nil but Backend.CreateMultipartUpload was just called")
	}
	callInfo := struct {
		ContextMoqParam            context.Context
		CreateMultipartUploadInput s3response.CreateMultipartUploadInput
	}{
		ContextMoqParam:            contextMoqParam,
		CreateMultipartUploadInput: createMultipartUploadInput,
	}
	mock.lockCreateMultipartUpload.Lock()
	mock.calls.CreateMultipartUpload = append(mock.calls.CreateMultipartUpload, callInfo)
	mock.lockCreateMultipartUpload.Unlock()
	return mock.CreateMultipartUploadFunc(contextMoqParam, createMultipartUploadInput)
}

// CreateMultipartUploadCalls gets all the calls that were made to CreateMultipartUpload.
// Check the length with:
//
//	len(mockedBackend.CreateMultipartUploadCalls())
func (mock *BackendMock) CreateMultipartUploadCalls() []struct {
	ContextMoqParam            context.Context
	CreateMultipartUploadInput s3response.CreateMultipartUploadInput
} {
	var calls []struct {
		ContextMoqParam            context.Context
		CreateMultipartUploadInput s3response.CreateMultipartUploadInput
	}
	mock.lockCreateMultipartUpload.RLock()
	calls = mock.calls.CreateMultipartUpload
	mock.lockCreateMultipartUpload.RUnlock()
	return calls
}

// DeleteBucket calls DeleteBucketFunc.
func (mock *BackendMock) DeleteBucket(contextMoqParam context.Context, bucket string) error {
	if mock.DeleteBucketFunc == nil {
		panic("BackendMock.DeleteBucketFunc: method is nil but Backend.DeleteBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockDeleteBucket.Lock()
	mock.calls.DeleteBucket = append(mock.calls.DeleteBucket, callInfo)
	mock.lockDeleteBucket.Unlock()
	return mock.DeleteBucketFunc(contextMoqParam, bucket)
}

// DeleteBucketCalls gets all the calls that were made to DeleteBucket.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketCalls())
func (mock *BackendMock) DeleteBucketCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucket.RLock()
	calls = mock.calls.DeleteBucket
	mock.lockDeleteBucket.RUnlock()
	return calls
}

// DeleteBucketCors calls DeleteBucketCorsFunc.
func (mock *BackendMock) DeleteBucketCors(contextMoqParam context.Context, bucket string) error {
	if mock.DeleteBucketCorsFunc == nil {
		panic("BackendMock.DeleteBucketCorsFunc: method is nil but Backend.DeleteBucketCors was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockDeleteBucketCors.Lock()
	mock.calls.DeleteBucketCors = append(mock.calls.DeleteBucketCors, callInfo)
	mock.lockDeleteBucketCors.Unlock()
	return mock.DeleteBucketCorsFunc(contextMoqParam, bucket)
}

// DeleteBucketCorsCalls gets all the calls that were made to DeleteBucketCors.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketCorsCalls())
func (mock *BackendMock) DeleteBucketCorsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucketCors.RLock()
	calls = mock.calls.DeleteBucketCors
	mock.lockDeleteBucketCors.RUnlock()
	return calls
}

// DeleteBucketOwnershipControls calls DeleteBucketOwnershipControlsFunc.
func (mock *BackendMock) DeleteBucketOwnershipControls(contextMoqParam context.Context, bucket string) error {
	if mock.DeleteBucketOwnershipControlsFunc == nil {
		panic("BackendMock.DeleteBucketOwnershipControlsFunc: method is nil but Backend.DeleteBucketOwnershipControls was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockDeleteBucketOwnershipControls.Lock()
	mock.calls.DeleteBucketOwnershipControls = append(mock.calls.DeleteBucketOwnershipControls, callInfo)
	mock.lockDeleteBucketOwnershipControls.Unlock()
	return mock.DeleteBucketOwnershipControlsFunc(contextMoqParam, bucket)
}

// DeleteBucketOwnershipControlsCalls gets all the calls that were made to DeleteBucketOwnershipControls.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketOwnershipControlsCalls())
func (mock *BackendMock) DeleteBucketOwnershipControlsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucketOwnershipControls.RLock()
	calls = mock.calls.DeleteBucketOwnershipControls
	mock.lockDeleteBucketOwnershipControls.RUnlock()
	return calls
}

// DeleteBucketPolicy calls DeleteBucketPolicyFunc.
func (mock *BackendMock) DeleteBucketPolicy(contextMoqParam context.Context, bucket string) error {
	if mock.DeleteBucketPolicyFunc == nil {
		panic("BackendMock.DeleteBucketPolicyFunc: method is nil but Backend.DeleteBucketPolicy was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockDeleteBucketPolicy.Lock()
	mock.calls.DeleteBucketPolicy = append(mock.calls.DeleteBucketPolicy, callInfo)
	mock.lockDeleteBucketPolicy.Unlock()
	return mock.DeleteBucketPolicyFunc(contextMoqParam, bucket)
}

// DeleteBucketPolicyCalls gets all the calls that were made to DeleteBucketPolicy.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketPolicyCalls())
func (mock *BackendMock) DeleteBucketPolicyCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucketPolicy.RLock()
	calls = mock.calls.DeleteBucketPolicy
	mock.lockDeleteBucketPolicy.RUnlock()
	return calls
}

// DeleteBucketTagging calls DeleteBucketTaggingFunc.
func (mock *BackendMock) DeleteBucketTagging(contextMoqParam context.Context, bucket string) error {
	if mock.DeleteBucketTaggingFunc == nil {
		panic("BackendMock.DeleteBucketTaggingFunc: method is nil but Backend.DeleteBucketTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockDeleteBucketTagging.Lock()
	mock.calls.DeleteBucketTagging = append(mock.calls.DeleteBucketTagging, callInfo)
	mock.lockDeleteBucketTagging.Unlock()
	return mock.DeleteBucketTaggingFunc(contextMoqParam, bucket)
}

// DeleteBucketTaggingCalls gets all the calls that were made to DeleteBucketTagging.
// Check the length with:
//
//	len(mockedBackend.DeleteBucketTaggingCalls())
func (mock *BackendMock) DeleteBucketTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockDeleteBucketTagging.RLock()
	calls = mock.calls.DeleteBucketTagging
	mock.lockDeleteBucketTagging.RUnlock()
	return calls
}

// DeleteObject calls DeleteObjectFunc.
func (mock *BackendMock) DeleteObject(contextMoqParam context.Context, deleteObjectInput *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
	if mock.DeleteObjectFunc == nil {
		panic("BackendMock.DeleteObjectFunc: method is nil but Backend.DeleteObject was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		DeleteObjectInput *s3.DeleteObjectInput
	}{
		ContextMoqParam:   contextMoqParam,
		DeleteObjectInput: deleteObjectInput,
	}
	mock.lockDeleteObject.Lock()
	mock.calls.DeleteObject = append(mock.calls.DeleteObject, callInfo)
	mock.lockDeleteObject.Unlock()
	return mock.DeleteObjectFunc(contextMoqParam, deleteObjectInput)
}

// DeleteObjectCalls gets all the calls that were made to DeleteObject.
// Check the length with:
//
//	len(mockedBackend.DeleteObjectCalls())
func (mock *BackendMock) DeleteObjectCalls() []struct {
	ContextMoqParam   context.Context
	DeleteObjectInput *s3.DeleteObjectInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		DeleteObjectInput *s3.DeleteObjectInput
	}
	mock.lockDeleteObject.RLock()
	calls = mock.calls.DeleteObject
	mock.lockDeleteObject.RUnlock()
	return calls
}

// DeleteObjectTagging calls DeleteObjectTaggingFunc.
func (mock *BackendMock) DeleteObjectTagging(contextMoqParam context.Context, bucket string, object string) error {
	if mock.DeleteObjectTaggingFunc == nil {
		panic("BackendMock.DeleteObjectTaggingFunc: method is nil but Backend.DeleteObjectTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
	}
	mock.lockDeleteObjectTagging.Lock()
	mock.calls.DeleteObjectTagging = append(mock.calls.DeleteObjectTagging, callInfo)
	mock.lockDeleteObjectTagging.Unlock()
	return mock.DeleteObjectTaggingFunc(contextMoqParam, bucket, object)
}

// DeleteObjectTaggingCalls gets all the calls that were made to DeleteObjectTagging.
// Check the length with:
//
//	len(mockedBackend.DeleteObjectTaggingCalls())
func (mock *BackendMock) DeleteObjectTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}
	mock.lockDeleteObjectTagging.RLock()
	calls = mock.calls.DeleteObjectTagging
	mock.lockDeleteObjectTagging.RUnlock()
	return calls
}

// DeleteObjects calls DeleteObjectsFunc.
func (mock *BackendMock) DeleteObjects(contextMoqParam context.Context, deleteObjectsInput *s3.DeleteObjectsInput) (s3response.DeleteResult, error) {
	if mock.DeleteObjectsFunc == nil {
		panic("BackendMock.DeleteObjectsFunc: method is nil but Backend.DeleteObjects was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		DeleteObjectsInput *s3.DeleteObjectsInput
	}{
		ContextMoqParam:    contextMoqParam,
		DeleteObjectsInput: deleteObjectsInput,
	}
	mock.lockDeleteObjects.Lock()
	mock.calls.DeleteObjects = append(mock.calls.DeleteObjects, callInfo)
	mock.lockDeleteObjects.Unlock()
	return mock.DeleteObjectsFunc(contextMoqParam, deleteObjectsInput)
}

// DeleteObjectsCalls gets all the calls that were made to DeleteObjects.
// Check the length with:
//
//	len(mockedBackend.DeleteObjectsCalls())
func (mock *BackendMock) DeleteObjectsCalls() []struct {
	ContextMoqParam    context.Context
	DeleteObjectsInput *s3.DeleteObjectsInput
} {
	var calls []struct {
		ContextMoqParam    context.Context
		DeleteObjectsInput *s3.DeleteObjectsInput
	}
	mock.lockDeleteObjects.RLock()
	calls = mock.calls.DeleteObjects
	mock.lockDeleteObjects.RUnlock()
	return calls
}

// GetBucketAcl calls GetBucketAclFunc.
func (mock *BackendMock) GetBucketAcl(contextMoqParam context.Context, getBucketAclInput *s3.GetBucketAclInput) ([]byte, error) {
	if mock.GetBucketAclFunc == nil {
		panic("BackendMock.GetBucketAclFunc: method is nil but Backend.GetBucketAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		GetBucketAclInput *s3.GetBucketAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		GetBucketAclInput: getBucketAclInput,
	}
	mock.lockGetBucketAcl.Lock()
	mock.calls.GetBucketAcl = append(mock.calls.GetBucketAcl, callInfo)
	mock.lockGetBucketAcl.Unlock()
	return mock.GetBucketAclFunc(contextMoqParam, getBucketAclInput)
}

// GetBucketAclCalls gets all the calls that were made to GetBucketAcl.
// Check the length with:
//
//	len(mockedBackend.GetBucketAclCalls())
func (mock *BackendMock) GetBucketAclCalls() []struct {
	ContextMoqParam   context.Context
	GetBucketAclInput *s3.GetBucketAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		GetBucketAclInput *s3.GetBucketAclInput
	}
	mock.lockGetBucketAcl.RLock()
	calls = mock.calls.GetBucketAcl
	mock.lockGetBucketAcl.RUnlock()
	return calls
}

// GetBucketCors calls GetBucketCorsFunc.
func (mock *BackendMock) GetBucketCors(contextMoqParam context.Context, bucket string) ([]byte, error) {
	if mock.GetBucketCorsFunc == nil {
		panic("BackendMock.GetBucketCorsFunc: method is nil but Backend.GetBucketCors was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketCors.Lock()
	mock.calls.GetBucketCors = append(mock.calls.GetBucketCors, callInfo)
	mock.lockGetBucketCors.Unlock()
	return mock.GetBucketCorsFunc(contextMoqParam, bucket)
}

// GetBucketCorsCalls gets all the calls that were made to GetBucketCors.
// Check the length with:
//
//	len(mockedBackend.GetBucketCorsCalls())
func (mock *BackendMock) GetBucketCorsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketCors.RLock()
	calls = mock.calls.GetBucketCors
	mock.lockGetBucketCors.RUnlock()
	return calls
}

// GetBucketOwnershipControls calls GetBucketOwnershipControlsFunc.
func (mock *BackendMock) GetBucketOwnershipControls(contextMoqParam context.Context, bucket string) (types.ObjectOwnership, error) {
	if mock.GetBucketOwnershipControlsFunc == nil {
		panic("BackendMock.GetBucketOwnershipControlsFunc: method is nil but Backend.GetBucketOwnershipControls was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketOwnershipControls.Lock()
	mock.calls.GetBucketOwnershipControls = append(mock.calls.GetBucketOwnershipControls, callInfo)
	mock.lockGetBucketOwnershipControls.Unlock()
	return mock.GetBucketOwnershipControlsFunc(contextMoqParam, bucket)
}

// GetBucketOwnershipControlsCalls gets all the calls that were made to GetBucketOwnershipControls.
// Check the length with:
//
//	len(mockedBackend.GetBucketOwnershipControlsCalls())
func (mock *BackendMock) GetBucketOwnershipControlsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketOwnershipControls.RLock()
	calls = mock.calls.GetBucketOwnershipControls
	mock.lockGetBucketOwnershipControls.RUnlock()
	return calls
}

// GetBucketPolicy calls GetBucketPolicyFunc.
func (mock *BackendMock) GetBucketPolicy(contextMoqParam context.Context, bucket string) ([]byte, error) {
	if mock.GetBucketPolicyFunc == nil {
		panic("BackendMock.GetBucketPolicyFunc: method is nil but Backend.GetBucketPolicy was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketPolicy.Lock()
	mock.calls.GetBucketPolicy = append(mock.calls.GetBucketPolicy, callInfo)
	mock.lockGetBucketPolicy.Unlock()
	return mock.GetBucketPolicyFunc(contextMoqParam, bucket)
}

// GetBucketPolicyCalls gets all the calls that were made to GetBucketPolicy.
// Check the length with:
//
//	len(mockedBackend.GetBucketPolicyCalls())
func (mock *BackendMock) GetBucketPolicyCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketPolicy.RLock()
	calls = mock.calls.GetBucketPolicy
	mock.lockGetBucketPolicy.RUnlock()
	return calls
}

// GetBucketTagging calls GetBucketTaggingFunc.
func (mock *BackendMock) GetBucketTagging(contextMoqParam context.Context, bucket string) (map[string]string, error) {
	if mock.GetBucketTaggingFunc == nil {
		panic("BackendMock.GetBucketTaggingFunc: method is nil but Backend.GetBucketTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketTagging.Lock()
	mock.calls.GetBucketTagging = append(mock.calls.GetBucketTagging, callInfo)
	mock.lockGetBucketTagging.Unlock()
	return mock.GetBucketTaggingFunc(contextMoqParam, bucket)
}

// GetBucketTaggingCalls gets all the calls that were made to GetBucketTagging.
// Check the length with:
//
//	len(mockedBackend.GetBucketTaggingCalls())
func (mock *BackendMock) GetBucketTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketTagging.RLock()
	calls = mock.calls.GetBucketTagging
	mock.lockGetBucketTagging.RUnlock()
	return calls
}

// GetBucketVersioning calls GetBucketVersioningFunc.
func (mock *BackendMock) GetBucketVersioning(contextMoqParam context.Context, bucket string) (s3response.GetBucketVersioningOutput, error) {
	if mock.GetBucketVersioningFunc == nil {
		panic("BackendMock.GetBucketVersioningFunc: method is nil but Backend.GetBucketVersioning was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetBucketVersioning.Lock()
	mock.calls.GetBucketVersioning = append(mock.calls.GetBucketVersioning, callInfo)
	mock.lockGetBucketVersioning.Unlock()
	return mock.GetBucketVersioningFunc(contextMoqParam, bucket)
}

// GetBucketVersioningCalls gets all the calls that were made to GetBucketVersioning.
// Check the length with:
//
//	len(mockedBackend.GetBucketVersioningCalls())
func (mock *BackendMock) GetBucketVersioningCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetBucketVersioning.RLock()
	calls = mock.calls.GetBucketVersioning
	mock.lockGetBucketVersioning.RUnlock()
	return calls
}

// GetObject calls GetObjectFunc.
func (mock *BackendMock) GetObject(contextMoqParam context.Context, getObjectInput *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
	if mock.GetObjectFunc == nil {
		panic("BackendMock.GetObjectFunc: method is nil but Backend.GetObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		GetObjectInput  *s3.GetObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		GetObjectInput:  getObjectInput,
	}
	mock.lockGetObject.Lock()
	mock.calls.GetObject = append(mock.calls.GetObject, callInfo)
	mock.lockGetObject.Unlock()
	return mock.GetObjectFunc(contextMoqParam, getObjectInput)
}

// GetObjectCalls gets all the calls that were made to GetObject.
// Check the length with:
//
//	len(mockedBackend.GetObjectCalls())
func (mock *BackendMock) GetObjectCalls() []struct {
	ContextMoqParam context.Context
	GetObjectInput  *s3.GetObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		GetObjectInput  *s3.GetObjectInput
	}
	mock.lockGetObject.RLock()
	calls = mock.calls.GetObject
	mock.lockGetObject.RUnlock()
	return calls
}

// GetObjectAcl calls GetObjectAclFunc.
func (mock *BackendMock) GetObjectAcl(contextMoqParam context.Context, getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
	if mock.GetObjectAclFunc == nil {
		panic("BackendMock.GetObjectAclFunc: method is nil but Backend.GetObjectAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		GetObjectAclInput *s3.GetObjectAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		GetObjectAclInput: getObjectAclInput,
	}
	mock.lockGetObjectAcl.Lock()
	mock.calls.GetObjectAcl = append(mock.calls.GetObjectAcl, callInfo)
	mock.lockGetObjectAcl.Unlock()
	return mock.GetObjectAclFunc(contextMoqParam, getObjectAclInput)
}

// GetObjectAclCalls gets all the calls that were made to GetObjectAcl.
// Check the length with:
//
//	len(mockedBackend.GetObjectAclCalls())
func (mock *BackendMock) GetObjectAclCalls() []struct {
	ContextMoqParam   context.Context
	GetObjectAclInput *s3.GetObjectAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		GetObjectAclInput *s3.GetObjectAclInput
	}
	mock.lockGetObjectAcl.RLock()
	calls = mock.calls.GetObjectAcl
	mock.lockGetObjectAcl.RUnlock()
	return calls
}

// GetObjectAttributes calls GetObjectAttributesFunc.
func (mock *BackendMock) GetObjectAttributes(contextMoqParam context.Context, getObjectAttributesInput *s3.GetObjectAttributesInput) (s3response.GetObjectAttributesResponse, error) {
	if mock.GetObjectAttributesFunc == nil {
		panic("BackendMock.GetObjectAttributesFunc: method is nil but Backend.GetObjectAttributes was just called")
	}
	callInfo := struct {
		ContextMoqParam          context.Context
		GetObjectAttributesInput *s3.GetObjectAttributesInput
	}{
		ContextMoqParam:          contextMoqParam,
		GetObjectAttributesInput: getObjectAttributesInput,
	}
	mock.lockGetObjectAttributes.Lock()
	mock.calls.GetObjectAttributes = append(mock.calls.GetObjectAttributes, callInfo)
	mock.lockGetObjectAttributes.Unlock()
	return mock.GetObjectAttributesFunc(contextMoqParam, getObjectAttributesInput)
}

// GetObjectAttributesCalls gets all the calls that were made to GetObjectAttributes.
// Check the length with:
//
//	len(mockedBackend.GetObjectAttributesCalls())
func (mock *BackendMock) GetObjectAttributesCalls() []struct {
	ContextMoqParam          context.Context
	GetObjectAttributesInput *s3.GetObjectAttributesInput
} {
	var calls []struct {
		ContextMoqParam          context.Context
		GetObjectAttributesInput *s3.GetObjectAttributesInput
	}
	mock.lockGetObjectAttributes.RLock()
	calls = mock.calls.GetObjectAttributes
	mock.lockGetObjectAttributes.RUnlock()
	return calls
}

// GetObjectLegalHold calls GetObjectLegalHoldFunc.
func (mock *BackendMock) GetObjectLegalHold(contextMoqParam context.Context, bucket string, object string, versionId string) (*bool, error) {
	if mock.GetObjectLegalHoldFunc == nil {
		panic("BackendMock.GetObjectLegalHoldFunc: method is nil but Backend.GetObjectLegalHold was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		VersionId:       versionId,
	}
	mock.lockGetObjectLegalHold.Lock()
	mock.calls.GetObjectLegalHold = append(mock.calls.GetObjectLegalHold, callInfo)
	mock.lockGetObjectLegalHold.Unlock()
	return mock.GetObjectLegalHoldFunc(contextMoqParam, bucket, object, versionId)
}

// GetObjectLegalHoldCalls gets all the calls that were made to GetObjectLegalHold.
// Check the length with:
//
//	len(mockedBackend.GetObjectLegalHoldCalls())
func (mock *BackendMock) GetObjectLegalHoldCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	VersionId       string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
	}
	mock.lockGetObjectLegalHold.RLock()
	calls = mock.calls.GetObjectLegalHold
	mock.lockGetObjectLegalHold.RUnlock()
	return calls
}

// GetObjectLockConfiguration calls GetObjectLockConfigurationFunc.
func (mock *BackendMock) GetObjectLockConfiguration(contextMoqParam context.Context, bucket string) ([]byte, error) {
	if mock.GetObjectLockConfigurationFunc == nil {
		panic("BackendMock.GetObjectLockConfigurationFunc: method is nil but Backend.GetObjectLockConfiguration was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
	}
	mock.lockGetObjectLockConfiguration.Lock()
	mock.calls.GetObjectLockConfiguration = append(mock.calls.GetObjectLockConfiguration, callInfo)
	mock.lockGetObjectLockConfiguration.Unlock()
	return mock.GetObjectLockConfigurationFunc(contextMoqParam, bucket)
}

// GetObjectLockConfigurationCalls gets all the calls that were made to GetObjectLockConfiguration.
// Check the length with:
//
//	len(mockedBackend.GetObjectLockConfigurationCalls())
func (mock *BackendMock) GetObjectLockConfigurationCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
	}
	mock.lockGetObjectLockConfiguration.RLock()
	calls = mock.calls.GetObjectLockConfiguration
	mock.lockGetObjectLockConfiguration.RUnlock()
	return calls
}

// GetObjectRetention calls GetObjectRetentionFunc.
func (mock *BackendMock) GetObjectRetention(contextMoqParam context.Context, bucket string, object string, versionId string) ([]byte, error) {
	if mock.GetObjectRetentionFunc == nil {
		panic("BackendMock.GetObjectRetentionFunc: method is nil but Backend.GetObjectRetention was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		VersionId:       versionId,
	}
	mock.lockGetObjectRetention.Lock()
	mock.calls.GetObjectRetention = append(mock.calls.GetObjectRetention, callInfo)
	mock.lockGetObjectRetention.Unlock()
	return mock.GetObjectRetentionFunc(contextMoqParam, bucket, object, versionId)
}

// GetObjectRetentionCalls gets all the calls that were made to GetObjectRetention.
// Check the length with:
//
//	len(mockedBackend.GetObjectRetentionCalls())
func (mock *BackendMock) GetObjectRetentionCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	VersionId       string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
	}
	mock.lockGetObjectRetention.RLock()
	calls = mock.calls.GetObjectRetention
	mock.lockGetObjectRetention.RUnlock()
	return calls
}

// GetObjectTagging calls GetObjectTaggingFunc.
func (mock *BackendMock) GetObjectTagging(contextMoqParam context.Context, bucket string, object string) (map[string]string, error) {
	if mock.GetObjectTaggingFunc == nil {
		panic("BackendMock.GetObjectTaggingFunc: method is nil but Backend.GetObjectTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
	}
	mock.lockGetObjectTagging.Lock()
	mock.calls.GetObjectTagging = append(mock.calls.GetObjectTagging, callInfo)
	mock.lockGetObjectTagging.Unlock()
	return mock.GetObjectTaggingFunc(contextMoqParam, bucket, object)
}

// GetObjectTaggingCalls gets all the calls that were made to GetObjectTagging.
// Check the length with:
//
//	len(mockedBackend.GetObjectTaggingCalls())
func (mock *BackendMock) GetObjectTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
	}
	mock.lockGetObjectTagging.RLock()
	calls = mock.calls.GetObjectTagging
	mock.lockGetObjectTagging.RUnlock()
	return calls
}

// HeadBucket calls HeadBucketFunc.
func (mock *BackendMock) HeadBucket(contextMoqParam context.Context, headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
	if mock.HeadBucketFunc == nil {
		panic("BackendMock.HeadBucketFunc: method is nil but Backend.HeadBucket was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		HeadBucketInput *s3.HeadBucketInput
	}{
		ContextMoqParam: contextMoqParam,
		HeadBucketInput: headBucketInput,
	}
	mock.lockHeadBucket.Lock()
	mock.calls.HeadBucket = append(mock.calls.HeadBucket, callInfo)
	mock.lockHeadBucket.Unlock()
	return mock.HeadBucketFunc(contextMoqParam, headBucketInput)
}

// HeadBucketCalls gets all the calls that were made to HeadBucket.
// Check the length with:
//
//	len(mockedBackend.HeadBucketCalls())
func (mock *BackendMock) HeadBucketCalls() []struct {
	ContextMoqParam context.Context
	HeadBucketInput *s3.HeadBucketInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		HeadBucketInput *s3.HeadBucketInput
	}
	mock.lockHeadBucket.RLock()
	calls = mock.calls.HeadBucket
	mock.lockHeadBucket.RUnlock()
	return calls
}

// HeadObject calls HeadObjectFunc.
func (mock *BackendMock) HeadObject(contextMoqParam context.Context, headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
	if mock.HeadObjectFunc == nil {
		panic("BackendMock.HeadObjectFunc: method is nil but Backend.HeadObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		HeadObjectInput *s3.HeadObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		HeadObjectInput: headObjectInput,
	}
	mock.lockHeadObject.Lock()
	mock.calls.HeadObject = append(mock.calls.HeadObject, callInfo)
	mock.lockHeadObject.Unlock()
	return mock.HeadObjectFunc(contextMoqParam, headObjectInput)
}

// HeadObjectCalls gets all the calls that were made to HeadObject.
// Check the length with:
//
//	len(mockedBackend.HeadObjectCalls())
func (mock *BackendMock) HeadObjectCalls() []struct {
	ContextMoqParam context.Context
	HeadObjectInput *s3.HeadObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		HeadObjectInput *s3.HeadObjectInput
	}
	mock.lockHeadObject.RLock()
	calls = mock.calls.HeadObject
	mock.lockHeadObject.RUnlock()
	return calls
}

// ListBuckets calls ListBucketsFunc.
func (mock *BackendMock) ListBuckets(contextMoqParam context.Context, listBucketsInput s3response.ListBucketsInput) (s3response.ListAllMyBucketsResult, error) {
	if mock.ListBucketsFunc == nil {
		panic("BackendMock.ListBucketsFunc: method is nil but Backend.ListBuckets was just called")
	}
	callInfo := struct {
		ContextMoqParam  context.Context
		ListBucketsInput s3response.ListBucketsInput
	}{
		ContextMoqParam:  contextMoqParam,
		ListBucketsInput: listBucketsInput,
	}
	mock.lockListBuckets.Lock()
	mock.calls.ListBuckets = append(mock.calls.ListBuckets, callInfo)
	mock.lockListBuckets.Unlock()
	return mock.ListBucketsFunc(contextMoqParam, listBucketsInput)
}

// ListBucketsCalls gets all the calls that were made to ListBuckets.
// Check the length with:
//
//	len(mockedBackend.ListBucketsCalls())
func (mock *BackendMock) ListBucketsCalls() []struct {
	ContextMoqParam  context.Context
	ListBucketsInput s3response.ListBucketsInput
} {
	var calls []struct {
		ContextMoqParam  context.Context
		ListBucketsInput s3response.ListBucketsInput
	}
	mock.lockListBuckets.RLock()
	calls = mock.calls.ListBuckets
	mock.lockListBuckets.RUnlock()
	return calls
}

// ListBucketsAndOwners calls ListBucketsAndOwnersFunc.
func (mock *BackendMock) ListBucketsAndOwners(contextMoqParam context.Context) ([]s3response.Bucket, error) {
	if mock.ListBucketsAndOwnersFunc == nil {
		panic("BackendMock.ListBucketsAndOwnersFunc: method is nil but Backend.ListBucketsAndOwners was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
	}{
		ContextMoqParam: contextMoqParam,
	}
	mock.lockListBucketsAndOwners.Lock()
	mock.calls.ListBucketsAndOwners = append(mock.calls.ListBucketsAndOwners, callInfo)
	mock.lockListBucketsAndOwners.Unlock()
	return mock.ListBucketsAndOwnersFunc(contextMoqParam)
}

// ListBucketsAndOwnersCalls gets all the calls that were made to ListBucketsAndOwners.
// Check the length with:
//
//	len(mockedBackend.ListBucketsAndOwnersCalls())
func (mock *BackendMock) ListBucketsAndOwnersCalls() []struct {
	ContextMoqParam context.Context
} {
	var calls []struct {
		ContextMoqParam context.Context
	}
	mock.lockListBucketsAndOwners.RLock()
	calls = mock.calls.ListBucketsAndOwners
	mock.lockListBucketsAndOwners.RUnlock()
	return calls
}

// ListMultipartUploads calls ListMultipartUploadsFunc.
func (mock *BackendMock) ListMultipartUploads(contextMoqParam context.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
	if mock.ListMultipartUploadsFunc == nil {
		panic("BackendMock.ListMultipartUploadsFunc: method is nil but Backend.ListMultipartUploads was just called")
	}
	callInfo := struct {
		ContextMoqParam           context.Context
		ListMultipartUploadsInput *s3.ListMultipartUploadsInput
	}{
		ContextMoqParam:           contextMoqParam,
		ListMultipartUploadsInput: listMultipartUploadsInput,
	}
	mock.lockListMultipartUploads.Lock()
	mock.calls.ListMultipartUploads = append(mock.calls.ListMultipartUploads, callInfo)
	mock.lockListMultipartUploads.Unlock()
	return mock.ListMultipartUploadsFunc(contextMoqParam, listMultipartUploadsInput)
}

// ListMultipartUploadsCalls gets all the calls that were made to ListMultipartUploads.
// Check the length with:
//
//	len(mockedBackend.ListMultipartUploadsCalls())
func (mock *BackendMock) ListMultipartUploadsCalls() []struct {
	ContextMoqParam           context.Context
	ListMultipartUploadsInput *s3.ListMultipartUploadsInput
} {
	var calls []struct {
		ContextMoqParam           context.Context
		ListMultipartUploadsInput *s3.ListMultipartUploadsInput
	}
	mock.lockListMultipartUploads.RLock()
	calls = mock.calls.ListMultipartUploads
	mock.lockListMultipartUploads.RUnlock()
	return calls
}

// ListObjectVersions calls ListObjectVersionsFunc.
func (mock *BackendMock) ListObjectVersions(contextMoqParam context.Context, listObjectVersionsInput *s3.ListObjectVersionsInput) (s3response.ListVersionsResult, error) {
	if mock.ListObjectVersionsFunc == nil {
		panic("BackendMock.ListObjectVersionsFunc: method is nil but Backend.ListObjectVersions was just called")
	}
	callInfo := struct {
		ContextMoqParam         context.Context
		ListObjectVersionsInput *s3.ListObjectVersionsInput
	}{
		ContextMoqParam:         contextMoqParam,
		ListObjectVersionsInput: listObjectVersionsInput,
	}
	mock.lockListObjectVersions.Lock()
	mock.calls.ListObjectVersions = append(mock.calls.ListObjectVersions, callInfo)
	mock.lockListObjectVersions.Unlock()
	return mock.ListObjectVersionsFunc(contextMoqParam, listObjectVersionsInput)
}

// ListObjectVersionsCalls gets all the calls that were made to ListObjectVersions.
// Check the length with:
//
//	len(mockedBackend.ListObjectVersionsCalls())
func (mock *BackendMock) ListObjectVersionsCalls() []struct {
	ContextMoqParam         context.Context
	ListObjectVersionsInput *s3.ListObjectVersionsInput
} {
	var calls []struct {
		ContextMoqParam         context.Context
		ListObjectVersionsInput *s3.ListObjectVersionsInput
	}
	mock.lockListObjectVersions.RLock()
	calls = mock.calls.ListObjectVersions
	mock.lockListObjectVersions.RUnlock()
	return calls
}

// ListObjects calls ListObjectsFunc.
func (mock *BackendMock) ListObjects(contextMoqParam context.Context, listObjectsInput *s3.ListObjectsInput) (s3response.ListObjectsResult, error) {
	if mock.ListObjectsFunc == nil {
		panic("BackendMock.ListObjectsFunc: method is nil but Backend.ListObjects was just called")
	}
	callInfo := struct {
		ContextMoqParam  context.Context
		ListObjectsInput *s3.ListObjectsInput
	}{
		ContextMoqParam:  contextMoqParam,
		ListObjectsInput: listObjectsInput,
	}
	mock.lockListObjects.Lock()
	mock.calls.ListObjects = append(mock.calls.ListObjects, callInfo)
	mock.lockListObjects.Unlock()
	return mock.ListObjectsFunc(contextMoqParam, listObjectsInput)
}

// ListObjectsCalls gets all the calls that were made to ListObjects.
// Check the length with:
//
//	len(mockedBackend.ListObjectsCalls())
func (mock *BackendMock) ListObjectsCalls() []struct {
	ContextMoqParam  context.Context
	ListObjectsInput *s3.ListObjectsInput
} {
	var calls []struct {
		ContextMoqParam  context.Context
		ListObjectsInput *s3.ListObjectsInput
	}
	mock.lockListObjects.RLock()
	calls = mock.calls.ListObjects
	mock.lockListObjects.RUnlock()
	return calls
}

// ListObjectsV2 calls ListObjectsV2Func.
func (mock *BackendMock) ListObjectsV2(contextMoqParam context.Context, listObjectsV2Input *s3.ListObjectsV2Input) (s3response.ListObjectsV2Result, error) {
	if mock.ListObjectsV2Func == nil {
		panic("BackendMock.ListObjectsV2Func: method is nil but Backend.ListObjectsV2 was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		ListObjectsV2Input *s3.ListObjectsV2Input
	}{
		ContextMoqParam:    contextMoqParam,
		ListObjectsV2Input: listObjectsV2Input,
	}
	mock.lockListObjectsV2.Lock()
	mock.calls.ListObjectsV2 = append(mock.calls.ListObjectsV2, callInfo)
	mock.lockListObjectsV2.Unlock()
	return mock.ListObjectsV2Func(contextMoqParam, listObjectsV2Input)
}

// ListObjectsV2Calls gets all the calls that were made to ListObjectsV2.
// Check the length with:
//
//	len(mockedBackend.ListObjectsV2Calls())
func (mock *BackendMock) ListObjectsV2Calls() []struct {
	ContextMoqParam    context.Context
	ListObjectsV2Input *s3.ListObjectsV2Input
} {
	var calls []struct {
		ContextMoqParam    context.Context
		ListObjectsV2Input *s3.ListObjectsV2Input
	}
	mock.lockListObjectsV2.RLock()
	calls = mock.calls.ListObjectsV2
	mock.lockListObjectsV2.RUnlock()
	return calls
}

// ListParts calls ListPartsFunc.
func (mock *BackendMock) ListParts(contextMoqParam context.Context, listPartsInput *s3.ListPartsInput) (s3response.ListPartsResult, error) {
	if mock.ListPartsFunc == nil {
		panic("BackendMock.ListPartsFunc: method is nil but Backend.ListParts was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		ListPartsInput  *s3.ListPartsInput
	}{
		ContextMoqParam: contextMoqParam,
		ListPartsInput:  listPartsInput,
	}
	mock.lockListParts.Lock()
	mock.calls.ListParts = append(mock.calls.ListParts, callInfo)
	mock.lockListParts.Unlock()
	return mock.ListPartsFunc(contextMoqParam, listPartsInput)
}

// ListPartsCalls gets all the calls that were made to ListParts.
// Check the length with:
//
//	len(mockedBackend.ListPartsCalls())
func (mock *BackendMock) ListPartsCalls() []struct {
	ContextMoqParam context.Context
	ListPartsInput  *s3.ListPartsInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		ListPartsInput  *s3.ListPartsInput
	}
	mock.lockListParts.RLock()
	calls = mock.calls.ListParts
	mock.lockListParts.RUnlock()
	return calls
}

// PutBucketAcl calls PutBucketAclFunc.
func (mock *BackendMock) PutBucketAcl(contextMoqParam context.Context, bucket string, data []byte) error {
	if mock.PutBucketAclFunc == nil {
		panic("BackendMock.PutBucketAclFunc: method is nil but Backend.PutBucketAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Data            []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Data:            data,
	}
	mock.lockPutBucketAcl.Lock()
	mock.calls.PutBucketAcl = append(mock.calls.PutBucketAcl, callInfo)
	mock.lockPutBucketAcl.Unlock()
	return mock.PutBucketAclFunc(contextMoqParam, bucket, data)
}

// PutBucketAclCalls gets all the calls that were made to PutBucketAcl.
// Check the length with:
//
//	len(mockedBackend.PutBucketAclCalls())
func (mock *BackendMock) PutBucketAclCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Data            []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Data            []byte
	}
	mock.lockPutBucketAcl.RLock()
	calls = mock.calls.PutBucketAcl
	mock.lockPutBucketAcl.RUnlock()
	return calls
}

// PutBucketCors calls PutBucketCorsFunc.
func (mock *BackendMock) PutBucketCors(contextMoqParam context.Context, bytes []byte) error {
	if mock.PutBucketCorsFunc == nil {
		panic("BackendMock.PutBucketCorsFunc: method is nil but Backend.PutBucketCors was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bytes           []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bytes:           bytes,
	}
	mock.lockPutBucketCors.Lock()
	mock.calls.PutBucketCors = append(mock.calls.PutBucketCors, callInfo)
	mock.lockPutBucketCors.Unlock()
	return mock.PutBucketCorsFunc(contextMoqParam, bytes)
}

// PutBucketCorsCalls gets all the calls that were made to PutBucketCors.
// Check the length with:
//
//	len(mockedBackend.PutBucketCorsCalls())
func (mock *BackendMock) PutBucketCorsCalls() []struct {
	ContextMoqParam context.Context
	Bytes           []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bytes           []byte
	}
	mock.lockPutBucketCors.RLock()
	calls = mock.calls.PutBucketCors
	mock.lockPutBucketCors.RUnlock()
	return calls
}

// PutBucketOwnershipControls calls PutBucketOwnershipControlsFunc.
func (mock *BackendMock) PutBucketOwnershipControls(contextMoqParam context.Context, bucket string, ownership types.ObjectOwnership) error {
	if mock.PutBucketOwnershipControlsFunc == nil {
		panic("BackendMock.PutBucketOwnershipControlsFunc: method is nil but Backend.PutBucketOwnershipControls was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Ownership       types.ObjectOwnership
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Ownership:       ownership,
	}
	mock.lockPutBucketOwnershipControls.Lock()
	mock.calls.PutBucketOwnershipControls = append(mock.calls.PutBucketOwnershipControls, callInfo)
	mock.lockPutBucketOwnershipControls.Unlock()
	return mock.PutBucketOwnershipControlsFunc(contextMoqParam, bucket, ownership)
}

// PutBucketOwnershipControlsCalls gets all the calls that were made to PutBucketOwnershipControls.
// Check the length with:
//
//	len(mockedBackend.PutBucketOwnershipControlsCalls())
func (mock *BackendMock) PutBucketOwnershipControlsCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Ownership       types.ObjectOwnership
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Ownership       types.ObjectOwnership
	}
	mock.lockPutBucketOwnershipControls.RLock()
	calls = mock.calls.PutBucketOwnershipControls
	mock.lockPutBucketOwnershipControls.RUnlock()
	return calls
}

// PutBucketPolicy calls PutBucketPolicyFunc.
func (mock *BackendMock) PutBucketPolicy(contextMoqParam context.Context, bucket string, policy []byte) error {
	if mock.PutBucketPolicyFunc == nil {
		panic("BackendMock.PutBucketPolicyFunc: method is nil but Backend.PutBucketPolicy was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Policy          []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Policy:          policy,
	}
	mock.lockPutBucketPolicy.Lock()
	mock.calls.PutBucketPolicy = append(mock.calls.PutBucketPolicy, callInfo)
	mock.lockPutBucketPolicy.Unlock()
	return mock.PutBucketPolicyFunc(contextMoqParam, bucket, policy)
}

// PutBucketPolicyCalls gets all the calls that were made to PutBucketPolicy.
// Check the length with:
//
//	len(mockedBackend.PutBucketPolicyCalls())
func (mock *BackendMock) PutBucketPolicyCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Policy          []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Policy          []byte
	}
	mock.lockPutBucketPolicy.RLock()
	calls = mock.calls.PutBucketPolicy
	mock.lockPutBucketPolicy.RUnlock()
	return calls
}

// PutBucketTagging calls PutBucketTaggingFunc.
func (mock *BackendMock) PutBucketTagging(contextMoqParam context.Context, bucket string, tags map[string]string) error {
	if mock.PutBucketTaggingFunc == nil {
		panic("BackendMock.PutBucketTaggingFunc: method is nil but Backend.PutBucketTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Tags            map[string]string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Tags:            tags,
	}
	mock.lockPutBucketTagging.Lock()
	mock.calls.PutBucketTagging = append(mock.calls.PutBucketTagging, callInfo)
	mock.lockPutBucketTagging.Unlock()
	return mock.PutBucketTaggingFunc(contextMoqParam, bucket, tags)
}

// PutBucketTaggingCalls gets all the calls that were made to PutBucketTagging.
// Check the length with:
//
//	len(mockedBackend.PutBucketTaggingCalls())
func (mock *BackendMock) PutBucketTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Tags            map[string]string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Tags            map[string]string
	}
	mock.lockPutBucketTagging.RLock()
	calls = mock.calls.PutBucketTagging
	mock.lockPutBucketTagging.RUnlock()
	return calls
}

// PutBucketVersioning calls PutBucketVersioningFunc.
func (mock *BackendMock) PutBucketVersioning(contextMoqParam context.Context, bucket string, status types.BucketVersioningStatus) error {
	if mock.PutBucketVersioningFunc == nil {
		panic("BackendMock.PutBucketVersioningFunc: method is nil but Backend.PutBucketVersioning was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Status          types.BucketVersioningStatus
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Status:          status,
	}
	mock.lockPutBucketVersioning.Lock()
	mock.calls.PutBucketVersioning = append(mock.calls.PutBucketVersioning, callInfo)
	mock.lockPutBucketVersioning.Unlock()
	return mock.PutBucketVersioningFunc(contextMoqParam, bucket, status)
}

// PutBucketVersioningCalls gets all the calls that were made to PutBucketVersioning.
// Check the length with:
//
//	len(mockedBackend.PutBucketVersioningCalls())
func (mock *BackendMock) PutBucketVersioningCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Status          types.BucketVersioningStatus
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Status          types.BucketVersioningStatus
	}
	mock.lockPutBucketVersioning.RLock()
	calls = mock.calls.PutBucketVersioning
	mock.lockPutBucketVersioning.RUnlock()
	return calls
}

// PutObject calls PutObjectFunc.
func (mock *BackendMock) PutObject(contextMoqParam context.Context, putObjectInput s3response.PutObjectInput) (s3response.PutObjectOutput, error) {
	if mock.PutObjectFunc == nil {
		panic("BackendMock.PutObjectFunc: method is nil but Backend.PutObject was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		PutObjectInput  s3response.PutObjectInput
	}{
		ContextMoqParam: contextMoqParam,
		PutObjectInput:  putObjectInput,
	}
	mock.lockPutObject.Lock()
	mock.calls.PutObject = append(mock.calls.PutObject, callInfo)
	mock.lockPutObject.Unlock()
	return mock.PutObjectFunc(contextMoqParam, putObjectInput)
}

// PutObjectCalls gets all the calls that were made to PutObject.
// Check the length with:
//
//	len(mockedBackend.PutObjectCalls())
func (mock *BackendMock) PutObjectCalls() []struct {
	ContextMoqParam context.Context
	PutObjectInput  s3response.PutObjectInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		PutObjectInput  s3response.PutObjectInput
	}
	mock.lockPutObject.RLock()
	calls = mock.calls.PutObject
	mock.lockPutObject.RUnlock()
	return calls
}

// PutObjectAcl calls PutObjectAclFunc.
func (mock *BackendMock) PutObjectAcl(contextMoqParam context.Context, putObjectAclInput *s3.PutObjectAclInput) error {
	if mock.PutObjectAclFunc == nil {
		panic("BackendMock.PutObjectAclFunc: method is nil but Backend.PutObjectAcl was just called")
	}
	callInfo := struct {
		ContextMoqParam   context.Context
		PutObjectAclInput *s3.PutObjectAclInput
	}{
		ContextMoqParam:   contextMoqParam,
		PutObjectAclInput: putObjectAclInput,
	}
	mock.lockPutObjectAcl.Lock()
	mock.calls.PutObjectAcl = append(mock.calls.PutObjectAcl, callInfo)
	mock.lockPutObjectAcl.Unlock()
	return mock.PutObjectAclFunc(contextMoqParam, putObjectAclInput)
}

// PutObjectAclCalls gets all the calls that were made to PutObjectAcl.
// Check the length with:
//
//	len(mockedBackend.PutObjectAclCalls())
func (mock *BackendMock) PutObjectAclCalls() []struct {
	ContextMoqParam   context.Context
	PutObjectAclInput *s3.PutObjectAclInput
} {
	var calls []struct {
		ContextMoqParam   context.Context
		PutObjectAclInput *s3.PutObjectAclInput
	}
	mock.lockPutObjectAcl.RLock()
	calls = mock.calls.PutObjectAcl
	mock.lockPutObjectAcl.RUnlock()
	return calls
}

// PutObjectLegalHold calls PutObjectLegalHoldFunc.
func (mock *BackendMock) PutObjectLegalHold(contextMoqParam context.Context, bucket string, object string, versionId string, status bool) error {
	if mock.PutObjectLegalHoldFunc == nil {
		panic("BackendMock.PutObjectLegalHoldFunc: method is nil but Backend.PutObjectLegalHold was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
		Status          bool
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		VersionId:       versionId,
		Status:          status,
	}
	mock.lockPutObjectLegalHold.Lock()
	mock.calls.PutObjectLegalHold = append(mock.calls.PutObjectLegalHold, callInfo)
	mock.lockPutObjectLegalHold.Unlock()
	return mock.PutObjectLegalHoldFunc(contextMoqParam, bucket, object, versionId, status)
}

// PutObjectLegalHoldCalls gets all the calls that were made to PutObjectLegalHold.
// Check the length with:
//
//	len(mockedBackend.PutObjectLegalHoldCalls())
func (mock *BackendMock) PutObjectLegalHoldCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	VersionId       string
	Status          bool
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
		Status          bool
	}
	mock.lockPutObjectLegalHold.RLock()
	calls = mock.calls.PutObjectLegalHold
	mock.lockPutObjectLegalHold.RUnlock()
	return calls
}

// PutObjectLockConfiguration calls PutObjectLockConfigurationFunc.
func (mock *BackendMock) PutObjectLockConfiguration(contextMoqParam context.Context, bucket string, config []byte) error {
	if mock.PutObjectLockConfigurationFunc == nil {
		panic("BackendMock.PutObjectLockConfigurationFunc: method is nil but Backend.PutObjectLockConfiguration was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Config          []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Config:          config,
	}
	mock.lockPutObjectLockConfiguration.Lock()
	mock.calls.PutObjectLockConfiguration = append(mock.calls.PutObjectLockConfiguration, callInfo)
	mock.lockPutObjectLockConfiguration.Unlock()
	return mock.PutObjectLockConfigurationFunc(contextMoqParam, bucket, config)
}

// PutObjectLockConfigurationCalls gets all the calls that were made to PutObjectLockConfiguration.
// Check the length with:
//
//	len(mockedBackend.PutObjectLockConfigurationCalls())
func (mock *BackendMock) PutObjectLockConfigurationCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Config          []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Config          []byte
	}
	mock.lockPutObjectLockConfiguration.RLock()
	calls = mock.calls.PutObjectLockConfiguration
	mock.lockPutObjectLockConfiguration.RUnlock()
	return calls
}

// PutObjectRetention calls PutObjectRetentionFunc.
func (mock *BackendMock) PutObjectRetention(contextMoqParam context.Context, bucket string, object string, versionId string, bypass bool, retention []byte) error {
	if mock.PutObjectRetentionFunc == nil {
		panic("BackendMock.PutObjectRetentionFunc: method is nil but Backend.PutObjectRetention was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
		Bypass          bool
		Retention       []byte
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		VersionId:       versionId,
		Bypass:          bypass,
		Retention:       retention,
	}
	mock.lockPutObjectRetention.Lock()
	mock.calls.PutObjectRetention = append(mock.calls.PutObjectRetention, callInfo)
	mock.lockPutObjectRetention.Unlock()
	return mock.PutObjectRetentionFunc(contextMoqParam, bucket, object, versionId, bypass, retention)
}

// PutObjectRetentionCalls gets all the calls that were made to PutObjectRetention.
// Check the length with:
//
//	len(mockedBackend.PutObjectRetentionCalls())
func (mock *BackendMock) PutObjectRetentionCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	VersionId       string
	Bypass          bool
	Retention       []byte
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		VersionId       string
		Bypass          bool
		Retention       []byte
	}
	mock.lockPutObjectRetention.RLock()
	calls = mock.calls.PutObjectRetention
	mock.lockPutObjectRetention.RUnlock()
	return calls
}

// PutObjectTagging calls PutObjectTaggingFunc.
func (mock *BackendMock) PutObjectTagging(contextMoqParam context.Context, bucket string, object string, tags map[string]string) error {
	if mock.PutObjectTaggingFunc == nil {
		panic("BackendMock.PutObjectTaggingFunc: method is nil but Backend.PutObjectTagging was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		Tags            map[string]string
	}{
		ContextMoqParam: contextMoqParam,
		Bucket:          bucket,
		Object:          object,
		Tags:            tags,
	}
	mock.lockPutObjectTagging.Lock()
	mock.calls.PutObjectTagging = append(mock.calls.PutObjectTagging, callInfo)
	mock.lockPutObjectTagging.Unlock()
	return mock.PutObjectTaggingFunc(contextMoqParam, bucket, object, tags)
}

// PutObjectTaggingCalls gets all the calls that were made to PutObjectTagging.
// Check the length with:
//
//	len(mockedBackend.PutObjectTaggingCalls())
func (mock *BackendMock) PutObjectTaggingCalls() []struct {
	ContextMoqParam context.Context
	Bucket          string
	Object          string
	Tags            map[string]string
} {
	var calls []struct {
		ContextMoqParam context.Context
		Bucket          string
		Object          string
		Tags            map[string]string
	}
	mock.lockPutObjectTagging.RLock()
	calls = mock.calls.PutObjectTagging
	mock.lockPutObjectTagging.RUnlock()
	return calls
}

// RestoreObject calls RestoreObjectFunc.
func (mock *BackendMock) RestoreObject(contextMoqParam context.Context, restoreObjectInput *s3.RestoreObjectInput) error {
	if mock.RestoreObjectFunc == nil {
		panic("BackendMock.RestoreObjectFunc: method is nil but Backend.RestoreObject was just called")
	}
	callInfo := struct {
		ContextMoqParam    context.Context
		RestoreObjectInput *s3.RestoreObjectInput
	}{
		ContextMoqParam:    contextMoqParam,
		RestoreObjectInput: restoreObjectInput,
	}
	mock.lockRestoreObject.Lock()
	mock.calls.RestoreObject = append(mock.calls.RestoreObject, callInfo)
	mock.lockRestoreObject.Unlock()
	return mock.RestoreObjectFunc(contextMoqParam, restoreObjectInput)
}

// RestoreObjectCalls gets all the calls that were made to RestoreObject.
// Check the length with:
//
//	len(mockedBackend.RestoreObjectCalls())
func (mock *BackendMock) RestoreObjectCalls() []struct {
	ContextMoqParam    context.Context
	RestoreObjectInput *s3.RestoreObjectInput
} {
	var calls []struct {
		ContextMoqParam    context.Context
		RestoreObjectInput *s3.RestoreObjectInput
	}
	mock.lockRestoreObject.RLock()
	calls = mock.calls.RestoreObject
	mock.lockRestoreObject.RUnlock()
	return calls
}

// SelectObjectContent calls SelectObjectContentFunc.
func (mock *BackendMock) SelectObjectContent(ctx context.Context, input *s3.SelectObjectContentInput) func(w *bufio.Writer) {
	if mock.SelectObjectContentFunc == nil {
		panic("BackendMock.SelectObjectContentFunc: method is nil but Backend.SelectObjectContent was just called")
	}
	callInfo := struct {
		Ctx   context.Context
		Input *s3.SelectObjectContentInput
	}{
		Ctx:   ctx,
		Input: input,
	}
	mock.lockSelectObjectContent.Lock()
	mock.calls.SelectObjectContent = append(mock.calls.SelectObjectContent, callInfo)
	mock.lockSelectObjectContent.Unlock()
	return mock.SelectObjectContentFunc(ctx, input)
}

// SelectObjectContentCalls gets all the calls that were made to SelectObjectContent.
// Check the length with:
//
//	len(mockedBackend.SelectObjectContentCalls())
func (mock *BackendMock) SelectObjectContentCalls() []struct {
	Ctx   context.Context
	Input *s3.SelectObjectContentInput
} {
	var calls []struct {
		Ctx   context.Context
		Input *s3.SelectObjectContentInput
	}
	mock.lockSelectObjectContent.RLock()
	calls = mock.calls.SelectObjectContent
	mock.lockSelectObjectContent.RUnlock()
	return calls
}

// Shutdown calls ShutdownFunc.
func (mock *BackendMock) Shutdown() {
	if mock.ShutdownFunc == nil {
		panic("BackendMock.ShutdownFunc: method is nil but Backend.Shutdown was just called")
	}
	callInfo := struct {
	}{}
	mock.lockShutdown.Lock()
	mock.calls.Shutdown = append(mock.calls.Shutdown, callInfo)
	mock.lockShutdown.Unlock()
	mock.ShutdownFunc()
}

// ShutdownCalls gets all the calls that were made to Shutdown.
// Check the length with:
//
//	len(mockedBackend.ShutdownCalls())
func (mock *BackendMock) ShutdownCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockShutdown.RLock()
	calls = mock.calls.Shutdown
	mock.lockShutdown.RUnlock()
	return calls
}

// String calls StringFunc.
func (mock *BackendMock) String() string {
	if mock.StringFunc == nil {
		panic("BackendMock.StringFunc: method is nil but Backend.String was just called")
	}
	callInfo := struct {
	}{}
	mock.lockString.Lock()
	mock.calls.String = append(mock.calls.String, callInfo)
	mock.lockString.Unlock()
	return mock.StringFunc()
}

// StringCalls gets all the calls that were made to String.
// Check the length with:
//
//	len(mockedBackend.StringCalls())
func (mock *BackendMock) StringCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockString.RLock()
	calls = mock.calls.String
	mock.lockString.RUnlock()
	return calls
}

// UploadPart calls UploadPartFunc.
func (mock *BackendMock) UploadPart(contextMoqParam context.Context, uploadPartInput *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
	if mock.UploadPartFunc == nil {
		panic("BackendMock.UploadPartFunc: method is nil but Backend.UploadPart was just called")
	}
	callInfo := struct {
		ContextMoqParam context.Context
		UploadPartInput *s3.UploadPartInput
	}{
		ContextMoqParam: contextMoqParam,
		UploadPartInput: uploadPartInput,
	}
	mock.lockUploadPart.Lock()
	mock.calls.UploadPart = append(mock.calls.UploadPart, callInfo)
	mock.lockUploadPart.Unlock()
	return mock.UploadPartFunc(contextMoqParam, uploadPartInput)
}

// UploadPartCalls gets all the calls that were made to UploadPart.
// Check the length with:
//
//	len(mockedBackend.UploadPartCalls())
func (mock *BackendMock) UploadPartCalls() []struct {
	ContextMoqParam context.Context
	UploadPartInput *s3.UploadPartInput
} {
	var calls []struct {
		ContextMoqParam context.Context
		UploadPartInput *s3.UploadPartInput
	}
	mock.lockUploadPart.RLock()
	calls = mock.calls.UploadPart
	mock.lockUploadPart.RUnlock()
	return calls
}

// UploadPartCopy calls UploadPartCopyFunc.
func (mock *BackendMock) UploadPartCopy(contextMoqParam context.Context, uploadPartCopyInput *s3.UploadPartCopyInput) (s3response.CopyPartResult, error) {
	if mock.UploadPartCopyFunc == nil {
		panic("BackendMock.UploadPartCopyFunc: method is nil but Backend.UploadPartCopy was just called")
	}
	callInfo := struct {
		ContextMoqParam     context.Context
		UploadPartCopyInput *s3.UploadPartCopyInput
	}{
		ContextMoqParam:     contextMoqParam,
		UploadPartCopyInput: uploadPartCopyInput,
	}
	mock.lockUploadPartCopy.Lock()
	mock.calls.UploadPartCopy = append(mock.calls.UploadPartCopy, callInfo)
	mock.lockUploadPartCopy.Unlock()
	return mock.UploadPartCopyFunc(contextMoqParam, uploadPartCopyInput)
}

// UploadPartCopyCalls gets all the calls that were made to UploadPartCopy.
// Check the length with:
//
//	len(mockedBackend.UploadPartCopyCalls())
func (mock *BackendMock) UploadPartCopyCalls() []struct {
	ContextMoqParam     context.Context
	UploadPartCopyInput *s3.UploadPartCopyInput
} {
	var calls []struct {
		ContextMoqParam     context.Context
		UploadPartCopyInput *s3.UploadPartCopyInput
	}
	mock.lockUploadPartCopy.RLock()
	calls = mock.calls.UploadPartCopy
	mock.lockUploadPartCopy.RUnlock()
	return calls
}