// Automatically generated by MockGen. DO NOT EDIT!
// Source: github.com/aws/aws-sdk-go/service/sqs/sqsiface (interfaces: SQSAPI)

package mock_sqsiface

import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	sqs "github.com/aws/aws-sdk-go/service/sqs"
	gomock "github.com/golang/mock/gomock"
)

// Mock of SQSAPI interface
type MockSQSAPI struct {
	ctrl     *gomock.Controller
	recorder *_MockSQSAPIRecorder
}

// Recorder for MockSQSAPI (not exported)
type _MockSQSAPIRecorder struct {
	mock *MockSQSAPI
}

func NewMockSQSAPI(ctrl *gomock.Controller) *MockSQSAPI {
	mock := &MockSQSAPI{ctrl: ctrl}
	mock.recorder = &_MockSQSAPIRecorder{mock}
	return mock
}

func (_m *MockSQSAPI) EXPECT() *_MockSQSAPIRecorder {
	return _m.recorder
}

func (_m *MockSQSAPI) AddPermission(_param0 *sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) {
	ret := _m.ctrl.Call(_m, "AddPermission", _param0)
	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) AddPermission(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddPermission", arg0)
}

func (_m *MockSQSAPI) AddPermissionRequest(_param0 *sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) {
	ret := _m.ctrl.Call(_m, "AddPermissionRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.AddPermissionOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) AddPermissionRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddPermissionRequest", arg0)
}

func (_m *MockSQSAPI) AddPermissionWithContext(_param0 aws.Context, _param1 *sqs.AddPermissionInput, _param2 ...request.Option) (*sqs.AddPermissionOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "AddPermissionWithContext", _s...)
	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) AddPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddPermissionWithContext", _s...)
}

func (_m *MockSQSAPI) ChangeMessageVisibility(_param0 *sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) {
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibility", _param0)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibility(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibility", arg0)
}

func (_m *MockSQSAPI) ChangeMessageVisibilityBatch(_param0 *sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibilityBatch", _param0)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibilityBatch(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibilityBatch", arg0)
}

func (_m *MockSQSAPI) ChangeMessageVisibilityBatchRequest(_param0 *sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) {
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibilityBatchRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityBatchOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibilityBatchRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibilityBatchRequest", arg0)
}

func (_m *MockSQSAPI) ChangeMessageVisibilityBatchWithContext(_param0 aws.Context, _param1 *sqs.ChangeMessageVisibilityBatchInput, _param2 ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibilityBatchWithContext", _s...)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibilityBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibilityBatchWithContext", _s...)
}

func (_m *MockSQSAPI) ChangeMessageVisibilityRequest(_param0 *sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) {
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibilityRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibilityRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibilityRequest", arg0)
}

func (_m *MockSQSAPI) ChangeMessageVisibilityWithContext(_param0 aws.Context, _param1 *sqs.ChangeMessageVisibilityInput, _param2 ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ChangeMessageVisibilityWithContext", _s...)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ChangeMessageVisibilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ChangeMessageVisibilityWithContext", _s...)
}

func (_m *MockSQSAPI) CreateQueue(_param0 *sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateQueue", _param0)
	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) CreateQueue(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateQueue", arg0)
}

func (_m *MockSQSAPI) CreateQueueRequest(_param0 *sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) {
	ret := _m.ctrl.Call(_m, "CreateQueueRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.CreateQueueOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) CreateQueueRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateQueueRequest", arg0)
}

func (_m *MockSQSAPI) CreateQueueWithContext(_param0 aws.Context, _param1 *sqs.CreateQueueInput, _param2 ...request.Option) (*sqs.CreateQueueOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateQueueWithContext", _s...)
	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) CreateQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateQueueWithContext", _s...)
}

func (_m *MockSQSAPI) DeleteMessage(_param0 *sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteMessage", _param0)
	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessage(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessage", arg0)
}

func (_m *MockSQSAPI) DeleteMessageBatch(_param0 *sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteMessageBatch", _param0)
	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessageBatch(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessageBatch", arg0)
}

func (_m *MockSQSAPI) DeleteMessageBatchRequest(_param0 *sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) {
	ret := _m.ctrl.Call(_m, "DeleteMessageBatchRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteMessageBatchOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessageBatchRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessageBatchRequest", arg0)
}

func (_m *MockSQSAPI) DeleteMessageBatchWithContext(_param0 aws.Context, _param1 *sqs.DeleteMessageBatchInput, _param2 ...request.Option) (*sqs.DeleteMessageBatchOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteMessageBatchWithContext", _s...)
	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessageBatchWithContext", _s...)
}

func (_m *MockSQSAPI) DeleteMessageRequest(_param0 *sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) {
	ret := _m.ctrl.Call(_m, "DeleteMessageRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteMessageOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessageRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessageRequest", arg0)
}

func (_m *MockSQSAPI) DeleteMessageWithContext(_param0 aws.Context, _param1 *sqs.DeleteMessageInput, _param2 ...request.Option) (*sqs.DeleteMessageOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteMessageWithContext", _s...)
	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteMessageWithContext", _s...)
}

func (_m *MockSQSAPI) DeleteQueue(_param0 *sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteQueue", _param0)
	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteQueue(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteQueue", arg0)
}

func (_m *MockSQSAPI) DeleteQueueRequest(_param0 *sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) {
	ret := _m.ctrl.Call(_m, "DeleteQueueRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteQueueOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteQueueRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteQueueRequest", arg0)
}

func (_m *MockSQSAPI) DeleteQueueWithContext(_param0 aws.Context, _param1 *sqs.DeleteQueueInput, _param2 ...request.Option) (*sqs.DeleteQueueOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteQueueWithContext", _s...)
	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) DeleteQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteQueueWithContext", _s...)
}

func (_m *MockSQSAPI) GetQueueAttributes(_param0 *sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) {
	ret := _m.ctrl.Call(_m, "GetQueueAttributes", _param0)
	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueAttributes(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueAttributes", arg0)
}

func (_m *MockSQSAPI) GetQueueAttributesRequest(_param0 *sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) {
	ret := _m.ctrl.Call(_m, "GetQueueAttributesRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.GetQueueAttributesOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueAttributesRequest", arg0)
}

func (_m *MockSQSAPI) GetQueueAttributesWithContext(_param0 aws.Context, _param1 *sqs.GetQueueAttributesInput, _param2 ...request.Option) (*sqs.GetQueueAttributesOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "GetQueueAttributesWithContext", _s...)
	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueAttributesWithContext", _s...)
}

func (_m *MockSQSAPI) GetQueueUrl(_param0 *sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) {
	ret := _m.ctrl.Call(_m, "GetQueueUrl", _param0)
	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueUrl(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueUrl", arg0)
}

func (_m *MockSQSAPI) GetQueueUrlRequest(_param0 *sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) {
	ret := _m.ctrl.Call(_m, "GetQueueUrlRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.GetQueueUrlOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueUrlRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueUrlRequest", arg0)
}

func (_m *MockSQSAPI) GetQueueUrlWithContext(_param0 aws.Context, _param1 *sqs.GetQueueUrlInput, _param2 ...request.Option) (*sqs.GetQueueUrlOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "GetQueueUrlWithContext", _s...)
	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) GetQueueUrlWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetQueueUrlWithContext", _s...)
}

func (_m *MockSQSAPI) ListDeadLetterSourceQueues(_param0 *sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
	ret := _m.ctrl.Call(_m, "ListDeadLetterSourceQueues", _param0)
	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListDeadLetterSourceQueues(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListDeadLetterSourceQueues", arg0)
}

func (_m *MockSQSAPI) ListDeadLetterSourceQueuesRequest(_param0 *sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) {
	ret := _m.ctrl.Call(_m, "ListDeadLetterSourceQueuesRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ListDeadLetterSourceQueuesOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListDeadLetterSourceQueuesRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListDeadLetterSourceQueuesRequest", arg0)
}

func (_m *MockSQSAPI) ListDeadLetterSourceQueuesWithContext(_param0 aws.Context, _param1 *sqs.ListDeadLetterSourceQueuesInput, _param2 ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListDeadLetterSourceQueuesWithContext", _s...)
	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListDeadLetterSourceQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListDeadLetterSourceQueuesWithContext", _s...)
}

func (_m *MockSQSAPI) ListQueues(_param0 *sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) {
	ret := _m.ctrl.Call(_m, "ListQueues", _param0)
	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListQueues(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListQueues", arg0)
}

func (_m *MockSQSAPI) ListQueuesRequest(_param0 *sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) {
	ret := _m.ctrl.Call(_m, "ListQueuesRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ListQueuesOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListQueuesRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListQueuesRequest", arg0)
}

func (_m *MockSQSAPI) ListQueuesWithContext(_param0 aws.Context, _param1 *sqs.ListQueuesInput, _param2 ...request.Option) (*sqs.ListQueuesOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListQueuesWithContext", _s...)
	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ListQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListQueuesWithContext", _s...)
}

func (_m *MockSQSAPI) PurgeQueue(_param0 *sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) {
	ret := _m.ctrl.Call(_m, "PurgeQueue", _param0)
	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) PurgeQueue(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PurgeQueue", arg0)
}

func (_m *MockSQSAPI) PurgeQueueRequest(_param0 *sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) {
	ret := _m.ctrl.Call(_m, "PurgeQueueRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.PurgeQueueOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) PurgeQueueRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PurgeQueueRequest", arg0)
}

func (_m *MockSQSAPI) PurgeQueueWithContext(_param0 aws.Context, _param1 *sqs.PurgeQueueInput, _param2 ...request.Option) (*sqs.PurgeQueueOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "PurgeQueueWithContext", _s...)
	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) PurgeQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PurgeQueueWithContext", _s...)
}

func (_m *MockSQSAPI) ReceiveMessage(_param0 *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) {
	ret := _m.ctrl.Call(_m, "ReceiveMessage", _param0)
	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ReceiveMessage(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReceiveMessage", arg0)
}

func (_m *MockSQSAPI) ReceiveMessageRequest(_param0 *sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) {
	ret := _m.ctrl.Call(_m, "ReceiveMessageRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ReceiveMessageOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ReceiveMessageRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReceiveMessageRequest", arg0)
}

func (_m *MockSQSAPI) ReceiveMessageWithContext(_param0 aws.Context, _param1 *sqs.ReceiveMessageInput, _param2 ...request.Option) (*sqs.ReceiveMessageOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ReceiveMessageWithContext", _s...)
	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) ReceiveMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReceiveMessageWithContext", _s...)
}

func (_m *MockSQSAPI) RemovePermission(_param0 *sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) {
	ret := _m.ctrl.Call(_m, "RemovePermission", _param0)
	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) RemovePermission(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemovePermission", arg0)
}

func (_m *MockSQSAPI) RemovePermissionRequest(_param0 *sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) {
	ret := _m.ctrl.Call(_m, "RemovePermissionRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.RemovePermissionOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemovePermissionRequest", arg0)
}

func (_m *MockSQSAPI) RemovePermissionWithContext(_param0 aws.Context, _param1 *sqs.RemovePermissionInput, _param2 ...request.Option) (*sqs.RemovePermissionOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "RemovePermissionWithContext", _s...)
	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) RemovePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RemovePermissionWithContext", _s...)
}

func (_m *MockSQSAPI) SendMessage(_param0 *sqs.SendMessageInput) (*sqs.SendMessageOutput, error) {
	ret := _m.ctrl.Call(_m, "SendMessage", _param0)
	ret0, _ := ret[0].(*sqs.SendMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessage(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessage", arg0)
}

func (_m *MockSQSAPI) SendMessageBatch(_param0 *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) {
	ret := _m.ctrl.Call(_m, "SendMessageBatch", _param0)
	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessageBatch(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessageBatch", arg0)
}

func (_m *MockSQSAPI) SendMessageBatchRequest(_param0 *sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) {
	ret := _m.ctrl.Call(_m, "SendMessageBatchRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SendMessageBatchOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessageBatchRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessageBatchRequest", arg0)
}

func (_m *MockSQSAPI) SendMessageBatchWithContext(_param0 aws.Context, _param1 *sqs.SendMessageBatchInput, _param2 ...request.Option) (*sqs.SendMessageBatchOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "SendMessageBatchWithContext", _s...)
	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessageBatchWithContext", _s...)
}

func (_m *MockSQSAPI) SendMessageRequest(_param0 *sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) {
	ret := _m.ctrl.Call(_m, "SendMessageRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SendMessageOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessageRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessageRequest", arg0)
}

func (_m *MockSQSAPI) SendMessageWithContext(_param0 aws.Context, _param1 *sqs.SendMessageInput, _param2 ...request.Option) (*sqs.SendMessageOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "SendMessageWithContext", _s...)
	ret0, _ := ret[0].(*sqs.SendMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SendMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SendMessageWithContext", _s...)
}

func (_m *MockSQSAPI) SetQueueAttributes(_param0 *sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) {
	ret := _m.ctrl.Call(_m, "SetQueueAttributes", _param0)
	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SetQueueAttributes(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetQueueAttributes", arg0)
}

func (_m *MockSQSAPI) SetQueueAttributesRequest(_param0 *sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) {
	ret := _m.ctrl.Call(_m, "SetQueueAttributesRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SetQueueAttributesOutput)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetQueueAttributesRequest", arg0)
}

func (_m *MockSQSAPI) SetQueueAttributesWithContext(_param0 aws.Context, _param1 *sqs.SetQueueAttributesInput, _param2 ...request.Option) (*sqs.SetQueueAttributesOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "SetQueueAttributesWithContext", _s...)
	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockSQSAPIRecorder) SetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetQueueAttributesWithContext", _s...)
}
