// Code generated by mockery v2.46.3. DO NOT EDIT.

package queuemock

import (
	context "context"

	mock "github.com/stretchr/testify/mock"

	sqs "github.com/aws/aws-sdk-go-v2/service/sqs"
)

// MockSQSClient is an autogenerated mock type for the SQSClient type
type MockSQSClient struct {
	mock.Mock
}

type MockSQSClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSQSClient) EXPECT() *MockSQSClient_Expecter {
	return &MockSQSClient_Expecter{mock: &_m.Mock}
}

// AddPermission provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) AddPermission(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for AddPermission")
	}

	var r0 *sqs.AddPermissionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) *sqs.AddPermissionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.AddPermissionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_AddPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermission'
type MockSQSClient_AddPermission_Call struct {
	*mock.Call
}

// AddPermission is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.AddPermissionInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) AddPermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_AddPermission_Call {
	return &MockSQSClient_AddPermission_Call{Call: _e.mock.On("AddPermission",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_AddPermission_Call) Run(run func(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_AddPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.AddPermissionInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_AddPermission_Call) Return(_a0 *sqs.AddPermissionOutput, _a1 error) *MockSQSClient_AddPermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_AddPermission_Call) RunAndReturn(run func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)) *MockSQSClient_AddPermission_Call {
	_c.Call.Return(run)
	return _c
}

// ChangeMessageVisibility provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) ChangeMessageVisibility(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ChangeMessageVisibility")
	}

	var r0 *sqs.ChangeMessageVisibilityOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_ChangeMessageVisibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibility'
type MockSQSClient_ChangeMessageVisibility_Call struct {
	*mock.Call
}

// ChangeMessageVisibility is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.ChangeMessageVisibilityInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) ChangeMessageVisibility(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibility_Call {
	return &MockSQSClient_ChangeMessageVisibility_Call{Call: _e.mock.On("ChangeMessageVisibility",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_ChangeMessageVisibility_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibility_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.ChangeMessageVisibilityInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_ChangeMessageVisibility_Call) Return(_a0 *sqs.ChangeMessageVisibilityOutput, _a1 error) *MockSQSClient_ChangeMessageVisibility_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_ChangeMessageVisibility_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)) *MockSQSClient_ChangeMessageVisibility_Call {
	_c.Call.Return(run)
	return _c
}

// ChangeMessageVisibilityBatch provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) ChangeMessageVisibilityBatch(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ChangeMessageVisibilityBatch")
	}

	var r0 *sqs.ChangeMessageVisibilityBatchOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityBatchOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityBatchOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_ChangeMessageVisibilityBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibilityBatch'
type MockSQSClient_ChangeMessageVisibilityBatch_Call struct {
	*mock.Call
}

// ChangeMessageVisibilityBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.ChangeMessageVisibilityBatchInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) ChangeMessageVisibilityBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
	return &MockSQSClient_ChangeMessageVisibilityBatch_Call{Call: _e.mock.On("ChangeMessageVisibilityBatch",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.ChangeMessageVisibilityBatchInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Return(_a0 *sqs.ChangeMessageVisibilityBatchOutput, _a1 error) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)) *MockSQSClient_ChangeMessageVisibilityBatch_Call {
	_c.Call.Return(run)
	return _c
}

// CreateQueue provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateQueue")
	}

	var r0 *sqs.CreateQueueOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) *sqs.CreateQueueOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.CreateQueueOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_CreateQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateQueue'
type MockSQSClient_CreateQueue_Call struct {
	*mock.Call
}

// CreateQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.CreateQueueInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) CreateQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_CreateQueue_Call {
	return &MockSQSClient_CreateQueue_Call{Call: _e.mock.On("CreateQueue",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_CreateQueue_Call) Run(run func(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_CreateQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.CreateQueueInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_CreateQueue_Call) Return(_a0 *sqs.CreateQueueOutput, _a1 error) *MockSQSClient_CreateQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_CreateQueue_Call) RunAndReturn(run func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)) *MockSQSClient_CreateQueue_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessage provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMessage")
	}

	var r0 *sqs.DeleteMessageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) *sqs.DeleteMessageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.DeleteMessageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
type MockSQSClient_DeleteMessage_Call struct {
	*mock.Call
}

// DeleteMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.DeleteMessageInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) DeleteMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessage_Call {
	return &MockSQSClient_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_DeleteMessage_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.DeleteMessageInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_DeleteMessage_Call) Return(_a0 *sqs.DeleteMessageOutput, _a1 error) *MockSQSClient_DeleteMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_DeleteMessage_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)) *MockSQSClient_DeleteMessage_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessageBatch provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMessageBatch")
	}

	var r0 *sqs.DeleteMessageBatchOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) *sqs.DeleteMessageBatchOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.DeleteMessageBatchOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_DeleteMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageBatch'
type MockSQSClient_DeleteMessageBatch_Call struct {
	*mock.Call
}

// DeleteMessageBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.DeleteMessageBatchInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) DeleteMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessageBatch_Call {
	return &MockSQSClient_DeleteMessageBatch_Call{Call: _e.mock.On("DeleteMessageBatch",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_DeleteMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteMessageBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.DeleteMessageBatchInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_DeleteMessageBatch_Call) Return(_a0 *sqs.DeleteMessageBatchOutput, _a1 error) *MockSQSClient_DeleteMessageBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_DeleteMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)) *MockSQSClient_DeleteMessageBatch_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteQueue provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) DeleteQueue(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for DeleteQueue")
	}

	var r0 *sqs.DeleteQueueOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) *sqs.DeleteQueueOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.DeleteQueueOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_DeleteQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteQueue'
type MockSQSClient_DeleteQueue_Call struct {
	*mock.Call
}

// DeleteQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.DeleteQueueInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) DeleteQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteQueue_Call {
	return &MockSQSClient_DeleteQueue_Call{Call: _e.mock.On("DeleteQueue",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_DeleteQueue_Call) Run(run func(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.DeleteQueueInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_DeleteQueue_Call) Return(_a0 *sqs.DeleteQueueOutput, _a1 error) *MockSQSClient_DeleteQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_DeleteQueue_Call) RunAndReturn(run func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)) *MockSQSClient_DeleteQueue_Call {
	_c.Call.Return(run)
	return _c
}

// GetQueueAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetQueueAttributes")
	}

	var r0 *sqs.GetQueueAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) *sqs.GetQueueAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.GetQueueAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_GetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueAttributes'
type MockSQSClient_GetQueueAttributes_Call struct {
	*mock.Call
}

// GetQueueAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.GetQueueAttributesInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) GetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueAttributes_Call {
	return &MockSQSClient_GetQueueAttributes_Call{Call: _e.mock.On("GetQueueAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_GetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_GetQueueAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.GetQueueAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_GetQueueAttributes_Call) Return(_a0 *sqs.GetQueueAttributesOutput, _a1 error) *MockSQSClient_GetQueueAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_GetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)) *MockSQSClient_GetQueueAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetQueueUrl provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for GetQueueUrl")
	}

	var r0 *sqs.GetQueueUrlOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) *sqs.GetQueueUrlOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.GetQueueUrlOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_GetQueueUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueUrl'
type MockSQSClient_GetQueueUrl_Call struct {
	*mock.Call
}

// GetQueueUrl is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.GetQueueUrlInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) GetQueueUrl(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueUrl_Call {
	return &MockSQSClient_GetQueueUrl_Call{Call: _e.mock.On("GetQueueUrl",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_GetQueueUrl_Call) Run(run func(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options))) *MockSQSClient_GetQueueUrl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.GetQueueUrlInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_GetQueueUrl_Call) Return(_a0 *sqs.GetQueueUrlOutput, _a1 error) *MockSQSClient_GetQueueUrl_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_GetQueueUrl_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)) *MockSQSClient_GetQueueUrl_Call {
	_c.Call.Return(run)
	return _c
}

// ListQueueTags provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) ListQueueTags(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListQueueTags")
	}

	var r0 *sqs.ListQueueTagsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) *sqs.ListQueueTagsOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.ListQueueTagsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_ListQueueTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueueTags'
type MockSQSClient_ListQueueTags_Call struct {
	*mock.Call
}

// ListQueueTags is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.ListQueueTagsInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) ListQueueTags(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueueTags_Call {
	return &MockSQSClient_ListQueueTags_Call{Call: _e.mock.On("ListQueueTags",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_ListQueueTags_Call) Run(run func(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueueTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.ListQueueTagsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_ListQueueTags_Call) Return(_a0 *sqs.ListQueueTagsOutput, _a1 error) *MockSQSClient_ListQueueTags_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_ListQueueTags_Call) RunAndReturn(run func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)) *MockSQSClient_ListQueueTags_Call {
	_c.Call.Return(run)
	return _c
}

// ListQueues provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) ListQueues(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ListQueues")
	}

	var r0 *sqs.ListQueuesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) *sqs.ListQueuesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.ListQueuesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_ListQueues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueues'
type MockSQSClient_ListQueues_Call struct {
	*mock.Call
}

// ListQueues is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.ListQueuesInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) ListQueues(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueues_Call {
	return &MockSQSClient_ListQueues_Call{Call: _e.mock.On("ListQueues",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_ListQueues_Call) Run(run func(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.ListQueuesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_ListQueues_Call) Return(_a0 *sqs.ListQueuesOutput, _a1 error) *MockSQSClient_ListQueues_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_ListQueues_Call) RunAndReturn(run func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)) *MockSQSClient_ListQueues_Call {
	_c.Call.Return(run)
	return _c
}

// PurgeQueue provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for PurgeQueue")
	}

	var r0 *sqs.PurgeQueueOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) *sqs.PurgeQueueOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.PurgeQueueOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_PurgeQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeQueue'
type MockSQSClient_PurgeQueue_Call struct {
	*mock.Call
}

// PurgeQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.PurgeQueueInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) PurgeQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_PurgeQueue_Call {
	return &MockSQSClient_PurgeQueue_Call{Call: _e.mock.On("PurgeQueue",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_PurgeQueue_Call) Run(run func(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_PurgeQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.PurgeQueueInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_PurgeQueue_Call) Return(_a0 *sqs.PurgeQueueOutput, _a1 error) *MockSQSClient_PurgeQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_PurgeQueue_Call) RunAndReturn(run func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)) *MockSQSClient_PurgeQueue_Call {
	_c.Call.Return(run)
	return _c
}

// ReceiveMessage provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for ReceiveMessage")
	}

	var r0 *sqs.ReceiveMessageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) *sqs.ReceiveMessageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.ReceiveMessageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_ReceiveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReceiveMessage'
type MockSQSClient_ReceiveMessage_Call struct {
	*mock.Call
}

// ReceiveMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.ReceiveMessageInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) ReceiveMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ReceiveMessage_Call {
	return &MockSQSClient_ReceiveMessage_Call{Call: _e.mock.On("ReceiveMessage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_ReceiveMessage_Call) Run(run func(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_ReceiveMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.ReceiveMessageInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_ReceiveMessage_Call) Return(_a0 *sqs.ReceiveMessageOutput, _a1 error) *MockSQSClient_ReceiveMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_ReceiveMessage_Call) RunAndReturn(run func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)) *MockSQSClient_ReceiveMessage_Call {
	_c.Call.Return(run)
	return _c
}

// RemovePermission provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) RemovePermission(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for RemovePermission")
	}

	var r0 *sqs.RemovePermissionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) *sqs.RemovePermissionOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.RemovePermissionOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_RemovePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermission'
type MockSQSClient_RemovePermission_Call struct {
	*mock.Call
}

// RemovePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.RemovePermissionInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) RemovePermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_RemovePermission_Call {
	return &MockSQSClient_RemovePermission_Call{Call: _e.mock.On("RemovePermission",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_RemovePermission_Call) Run(run func(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_RemovePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.RemovePermissionInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_RemovePermission_Call) Return(_a0 *sqs.RemovePermissionOutput, _a1 error) *MockSQSClient_RemovePermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_RemovePermission_Call) RunAndReturn(run func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)) *MockSQSClient_RemovePermission_Call {
	_c.Call.Return(run)
	return _c
}

// SendMessage provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) SendMessage(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SendMessage")
	}

	var r0 *sqs.SendMessageOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) *sqs.SendMessageOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.SendMessageOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage'
type MockSQSClient_SendMessage_Call struct {
	*mock.Call
}

// SendMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.SendMessageInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) SendMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessage_Call {
	return &MockSQSClient_SendMessage_Call{Call: _e.mock.On("SendMessage",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_SendMessage_Call) Run(run func(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_SendMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.SendMessageInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_SendMessage_Call) Return(_a0 *sqs.SendMessageOutput, _a1 error) *MockSQSClient_SendMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_SendMessage_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)) *MockSQSClient_SendMessage_Call {
	_c.Call.Return(run)
	return _c
}

// SendMessageBatch provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) SendMessageBatch(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SendMessageBatch")
	}

	var r0 *sqs.SendMessageBatchOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) *sqs.SendMessageBatchOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.SendMessageBatchOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_SendMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessageBatch'
type MockSQSClient_SendMessageBatch_Call struct {
	*mock.Call
}

// SendMessageBatch is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.SendMessageBatchInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) SendMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessageBatch_Call {
	return &MockSQSClient_SendMessageBatch_Call{Call: _e.mock.On("SendMessageBatch",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_SendMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_SendMessageBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.SendMessageBatchInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_SendMessageBatch_Call) Return(_a0 *sqs.SendMessageBatchOutput, _a1 error) *MockSQSClient_SendMessageBatch_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_SendMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)) *MockSQSClient_SendMessageBatch_Call {
	_c.Call.Return(run)
	return _c
}

// SetQueueAttributes provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for SetQueueAttributes")
	}

	var r0 *sqs.SetQueueAttributesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) *sqs.SetQueueAttributesOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.SetQueueAttributesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_SetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueueAttributes'
type MockSQSClient_SetQueueAttributes_Call struct {
	*mock.Call
}

// SetQueueAttributes is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.SetQueueAttributesInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) SetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SetQueueAttributes_Call {
	return &MockSQSClient_SetQueueAttributes_Call{Call: _e.mock.On("SetQueueAttributes",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_SetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_SetQueueAttributes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.SetQueueAttributesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_SetQueueAttributes_Call) Return(_a0 *sqs.SetQueueAttributesOutput, _a1 error) *MockSQSClient_SetQueueAttributes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_SetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)) *MockSQSClient_SetQueueAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// TagQueue provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) TagQueue(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options)) (*sqs.TagQueueOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for TagQueue")
	}

	var r0 *sqs.TagQueueOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) *sqs.TagQueueOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.TagQueueOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_TagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagQueue'
type MockSQSClient_TagQueue_Call struct {
	*mock.Call
}

// TagQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.TagQueueInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) TagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_TagQueue_Call {
	return &MockSQSClient_TagQueue_Call{Call: _e.mock.On("TagQueue",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_TagQueue_Call) Run(run func(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_TagQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.TagQueueInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_TagQueue_Call) Return(_a0 *sqs.TagQueueOutput, _a1 error) *MockSQSClient_TagQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_TagQueue_Call) RunAndReturn(run func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)) *MockSQSClient_TagQueue_Call {
	_c.Call.Return(run)
	return _c
}

// UntagQueue provides a mock function with given fields: ctx, params, optFns
func (_m *MockSQSClient) UntagQueue(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error) {
	_va := make([]interface{}, len(optFns))
	for _i := range optFns {
		_va[_i] = optFns[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for UntagQueue")
	}

	var r0 *sqs.UntagQueueOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)); ok {
		return rf(ctx, params, optFns...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) *sqs.UntagQueueOutput); ok {
		r0 = rf(ctx, params, optFns...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sqs.UntagQueueOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) error); ok {
		r1 = rf(ctx, params, optFns...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockSQSClient_UntagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagQueue'
type MockSQSClient_UntagQueue_Call struct {
	*mock.Call
}

// UntagQueue is a helper method to define mock.On call
//   - ctx context.Context
//   - params *sqs.UntagQueueInput
//   - optFns ...func(*sqs.Options)
func (_e *MockSQSClient_Expecter) UntagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_UntagQueue_Call {
	return &MockSQSClient_UntagQueue_Call{Call: _e.mock.On("UntagQueue",
		append([]interface{}{ctx, params}, optFns...)...)}
}

func (_c *MockSQSClient_UntagQueue_Call) Run(run func(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_UntagQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*sqs.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*sqs.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*sqs.UntagQueueInput), variadicArgs...)
	})
	return _c
}

func (_c *MockSQSClient_UntagQueue_Call) Return(_a0 *sqs.UntagQueueOutput, _a1 error) *MockSQSClient_UntagQueue_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSQSClient_UntagQueue_Call) RunAndReturn(run func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)) *MockSQSClient_UntagQueue_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSQSClient creates a new instance of MockSQSClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSQSClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSQSClient {
	mock := &MockSQSClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}