// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/buildkite/lifecycled (interfaces: SQSClient)

// Package mocks is a generated GoMock package.
package mocks

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

// MockSQSClient is a mock of SQSClient interface
type MockSQSClient struct {
	ctrl     *gomock.Controller
	recorder *MockSQSClientMockRecorder
}

// MockSQSClientMockRecorder is the mock recorder for MockSQSClient
type MockSQSClientMockRecorder struct {
	mock *MockSQSClient
}

// NewMockSQSClient creates a new mock instance
func NewMockSQSClient(ctrl *gomock.Controller) *MockSQSClient {
	mock := &MockSQSClient{ctrl: ctrl}
	mock.recorder = &MockSQSClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSQSClient) EXPECT() *MockSQSClientMockRecorder {
	return m.recorder
}

// AddPermission mocks base method
func (m *MockSQSClient) AddPermission(arg0 *sqs.AddPermissionInput) (*sqs.AddPermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPermission", arg0)
	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddPermission indicates an expected call of AddPermission
func (mr *MockSQSClientMockRecorder) AddPermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermission", reflect.TypeOf((*MockSQSClient)(nil).AddPermission), arg0)
}

// AddPermissionRequest mocks base method
func (m *MockSQSClient) AddPermissionRequest(arg0 *sqs.AddPermissionInput) (*request.Request, *sqs.AddPermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.AddPermissionOutput)
	return ret0, ret1
}

// AddPermissionRequest indicates an expected call of AddPermissionRequest
func (mr *MockSQSClientMockRecorder) AddPermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionRequest", reflect.TypeOf((*MockSQSClient)(nil).AddPermissionRequest), arg0)
}

// AddPermissionWithContext mocks base method
func (m *MockSQSClient) AddPermissionWithContext(arg0 context.Context, arg1 *sqs.AddPermissionInput, arg2 ...request.Option) (*sqs.AddPermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddPermissionWithContext indicates an expected call of AddPermissionWithContext
func (mr *MockSQSClientMockRecorder) AddPermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionWithContext", reflect.TypeOf((*MockSQSClient)(nil).AddPermissionWithContext), varargs...)
}

// ChangeMessageVisibility mocks base method
func (m *MockSQSClient) ChangeMessageVisibility(arg0 *sqs.ChangeMessageVisibilityInput) (*sqs.ChangeMessageVisibilityOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeMessageVisibility", arg0)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeMessageVisibility indicates an expected call of ChangeMessageVisibility
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibility(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibility", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibility), arg0)
}

// ChangeMessageVisibilityBatch mocks base method
func (m *MockSQSClient) ChangeMessageVisibilityBatch(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatch", arg0)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeMessageVisibilityBatch indicates an expected call of ChangeMessageVisibilityBatch
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibilityBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatch", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibilityBatch), arg0)
}

// ChangeMessageVisibilityBatchRequest mocks base method
func (m *MockSQSClient) ChangeMessageVisibilityBatchRequest(arg0 *sqs.ChangeMessageVisibilityBatchInput) (*request.Request, *sqs.ChangeMessageVisibilityBatchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityBatchOutput)
	return ret0, ret1
}

// ChangeMessageVisibilityBatchRequest indicates an expected call of ChangeMessageVisibilityBatchRequest
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibilityBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchRequest", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibilityBatchRequest), arg0)
}

// ChangeMessageVisibilityBatchWithContext mocks base method
func (m *MockSQSClient) ChangeMessageVisibilityBatchWithContext(arg0 context.Context, arg1 *sqs.ChangeMessageVisibilityBatchInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityBatchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeMessageVisibilityBatchWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeMessageVisibilityBatchWithContext indicates an expected call of ChangeMessageVisibilityBatchWithContext
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibilityBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchWithContext", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibilityBatchWithContext), varargs...)
}

// ChangeMessageVisibilityRequest mocks base method
func (m *MockSQSClient) ChangeMessageVisibilityRequest(arg0 *sqs.ChangeMessageVisibilityInput) (*request.Request, *sqs.ChangeMessageVisibilityOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeMessageVisibilityRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ChangeMessageVisibilityOutput)
	return ret0, ret1
}

// ChangeMessageVisibilityRequest indicates an expected call of ChangeMessageVisibilityRequest
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibilityRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityRequest", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibilityRequest), arg0)
}

// ChangeMessageVisibilityWithContext mocks base method
func (m *MockSQSClient) ChangeMessageVisibilityWithContext(arg0 context.Context, arg1 *sqs.ChangeMessageVisibilityInput, arg2 ...request.Option) (*sqs.ChangeMessageVisibilityOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeMessageVisibilityWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ChangeMessageVisibilityOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ChangeMessageVisibilityWithContext indicates an expected call of ChangeMessageVisibilityWithContext
func (mr *MockSQSClientMockRecorder) ChangeMessageVisibilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityWithContext", reflect.TypeOf((*MockSQSClient)(nil).ChangeMessageVisibilityWithContext), varargs...)
}

// CreateQueue mocks base method
func (m *MockSQSClient) CreateQueue(arg0 *sqs.CreateQueueInput) (*sqs.CreateQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateQueue", arg0)
	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateQueue indicates an expected call of CreateQueue
func (mr *MockSQSClientMockRecorder) CreateQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockSQSClient)(nil).CreateQueue), arg0)
}

// CreateQueueRequest mocks base method
func (m *MockSQSClient) CreateQueueRequest(arg0 *sqs.CreateQueueInput) (*request.Request, *sqs.CreateQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.CreateQueueOutput)
	return ret0, ret1
}

// CreateQueueRequest indicates an expected call of CreateQueueRequest
func (mr *MockSQSClientMockRecorder) CreateQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueRequest", reflect.TypeOf((*MockSQSClient)(nil).CreateQueueRequest), arg0)
}

// CreateQueueWithContext mocks base method
func (m *MockSQSClient) CreateQueueWithContext(arg0 context.Context, arg1 *sqs.CreateQueueInput, arg2 ...request.Option) (*sqs.CreateQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateQueueWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.CreateQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateQueueWithContext indicates an expected call of CreateQueueWithContext
func (mr *MockSQSClientMockRecorder) CreateQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueWithContext", reflect.TypeOf((*MockSQSClient)(nil).CreateQueueWithContext), varargs...)
}

// DeleteMessage mocks base method
func (m *MockSQSClient) DeleteMessage(arg0 *sqs.DeleteMessageInput) (*sqs.DeleteMessageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessage", arg0)
	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessage indicates an expected call of DeleteMessage
func (mr *MockSQSClientMockRecorder) DeleteMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessage), arg0)
}

// DeleteMessageBatch mocks base method
func (m *MockSQSClient) DeleteMessageBatch(arg0 *sqs.DeleteMessageBatchInput) (*sqs.DeleteMessageBatchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessageBatch", arg0)
	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessageBatch indicates an expected call of DeleteMessageBatch
func (mr *MockSQSClientMockRecorder) DeleteMessageBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatch", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessageBatch), arg0)
}

// DeleteMessageBatchRequest mocks base method
func (m *MockSQSClient) DeleteMessageBatchRequest(arg0 *sqs.DeleteMessageBatchInput) (*request.Request, *sqs.DeleteMessageBatchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessageBatchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteMessageBatchOutput)
	return ret0, ret1
}

// DeleteMessageBatchRequest indicates an expected call of DeleteMessageBatchRequest
func (mr *MockSQSClientMockRecorder) DeleteMessageBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchRequest", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessageBatchRequest), arg0)
}

// DeleteMessageBatchWithContext mocks base method
func (m *MockSQSClient) DeleteMessageBatchWithContext(arg0 context.Context, arg1 *sqs.DeleteMessageBatchInput, arg2 ...request.Option) (*sqs.DeleteMessageBatchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMessageBatchWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.DeleteMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessageBatchWithContext indicates an expected call of DeleteMessageBatchWithContext
func (mr *MockSQSClientMockRecorder) DeleteMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchWithContext", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessageBatchWithContext), varargs...)
}

// DeleteMessageRequest mocks base method
func (m *MockSQSClient) DeleteMessageRequest(arg0 *sqs.DeleteMessageInput) (*request.Request, *sqs.DeleteMessageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMessageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteMessageOutput)
	return ret0, ret1
}

// DeleteMessageRequest indicates an expected call of DeleteMessageRequest
func (mr *MockSQSClientMockRecorder) DeleteMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageRequest", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessageRequest), arg0)
}

// DeleteMessageWithContext mocks base method
func (m *MockSQSClient) DeleteMessageWithContext(arg0 context.Context, arg1 *sqs.DeleteMessageInput, arg2 ...request.Option) (*sqs.DeleteMessageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMessageWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.DeleteMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessageWithContext indicates an expected call of DeleteMessageWithContext
func (mr *MockSQSClientMockRecorder) DeleteMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageWithContext", reflect.TypeOf((*MockSQSClient)(nil).DeleteMessageWithContext), varargs...)
}

// DeleteQueue mocks base method
func (m *MockSQSClient) DeleteQueue(arg0 *sqs.DeleteQueueInput) (*sqs.DeleteQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteQueue", arg0)
	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteQueue indicates an expected call of DeleteQueue
func (mr *MockSQSClientMockRecorder) DeleteQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueue", reflect.TypeOf((*MockSQSClient)(nil).DeleteQueue), arg0)
}

// DeleteQueueRequest mocks base method
func (m *MockSQSClient) DeleteQueueRequest(arg0 *sqs.DeleteQueueInput) (*request.Request, *sqs.DeleteQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.DeleteQueueOutput)
	return ret0, ret1
}

// DeleteQueueRequest indicates an expected call of DeleteQueueRequest
func (mr *MockSQSClientMockRecorder) DeleteQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueRequest", reflect.TypeOf((*MockSQSClient)(nil).DeleteQueueRequest), arg0)
}

// DeleteQueueWithContext mocks base method
func (m *MockSQSClient) DeleteQueueWithContext(arg0 context.Context, arg1 *sqs.DeleteQueueInput, arg2 ...request.Option) (*sqs.DeleteQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteQueueWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.DeleteQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteQueueWithContext indicates an expected call of DeleteQueueWithContext
func (mr *MockSQSClientMockRecorder) DeleteQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueWithContext", reflect.TypeOf((*MockSQSClient)(nil).DeleteQueueWithContext), varargs...)
}

// GetQueueAttributes mocks base method
func (m *MockSQSClient) GetQueueAttributes(arg0 *sqs.GetQueueAttributesInput) (*sqs.GetQueueAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueAttributes", arg0)
	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueueAttributes indicates an expected call of GetQueueAttributes
func (mr *MockSQSClientMockRecorder) GetQueueAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributes", reflect.TypeOf((*MockSQSClient)(nil).GetQueueAttributes), arg0)
}

// GetQueueAttributesRequest mocks base method
func (m *MockSQSClient) GetQueueAttributesRequest(arg0 *sqs.GetQueueAttributesInput) (*request.Request, *sqs.GetQueueAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.GetQueueAttributesOutput)
	return ret0, ret1
}

// GetQueueAttributesRequest indicates an expected call of GetQueueAttributesRequest
func (mr *MockSQSClientMockRecorder) GetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesRequest", reflect.TypeOf((*MockSQSClient)(nil).GetQueueAttributesRequest), arg0)
}

// GetQueueAttributesWithContext mocks base method
func (m *MockSQSClient) GetQueueAttributesWithContext(arg0 context.Context, arg1 *sqs.GetQueueAttributesInput, arg2 ...request.Option) (*sqs.GetQueueAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueueAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.GetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueueAttributesWithContext indicates an expected call of GetQueueAttributesWithContext
func (mr *MockSQSClientMockRecorder) GetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesWithContext", reflect.TypeOf((*MockSQSClient)(nil).GetQueueAttributesWithContext), varargs...)
}

// GetQueueUrl mocks base method
func (m *MockSQSClient) GetQueueUrl(arg0 *sqs.GetQueueUrlInput) (*sqs.GetQueueUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueUrl", arg0)
	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueueUrl indicates an expected call of GetQueueUrl
func (mr *MockSQSClientMockRecorder) GetQueueUrl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockSQSClient)(nil).GetQueueUrl), arg0)
}

// GetQueueUrlRequest mocks base method
func (m *MockSQSClient) GetQueueUrlRequest(arg0 *sqs.GetQueueUrlInput) (*request.Request, *sqs.GetQueueUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.GetQueueUrlOutput)
	return ret0, ret1
}

// GetQueueUrlRequest indicates an expected call of GetQueueUrlRequest
func (mr *MockSQSClientMockRecorder) GetQueueUrlRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlRequest", reflect.TypeOf((*MockSQSClient)(nil).GetQueueUrlRequest), arg0)
}

// GetQueueUrlWithContext mocks base method
func (m *MockSQSClient) GetQueueUrlWithContext(arg0 context.Context, arg1 *sqs.GetQueueUrlInput, arg2 ...request.Option) (*sqs.GetQueueUrlOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueueUrlWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.GetQueueUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueueUrlWithContext indicates an expected call of GetQueueUrlWithContext
func (mr *MockSQSClientMockRecorder) GetQueueUrlWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlWithContext", reflect.TypeOf((*MockSQSClient)(nil).GetQueueUrlWithContext), varargs...)
}

// ListDeadLetterSourceQueues mocks base method
func (m *MockSQSClient) ListDeadLetterSourceQueues(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueues", arg0)
	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeadLetterSourceQueues indicates an expected call of ListDeadLetterSourceQueues
func (mr *MockSQSClientMockRecorder) ListDeadLetterSourceQueues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueues", reflect.TypeOf((*MockSQSClient)(nil).ListDeadLetterSourceQueues), arg0)
}

// ListDeadLetterSourceQueuesPages mocks base method
func (m *MockSQSClient) ListDeadLetterSourceQueuesPages(arg0 *sqs.ListDeadLetterSourceQueuesInput, arg1 func(*sqs.ListDeadLetterSourceQueuesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDeadLetterSourceQueuesPages indicates an expected call of ListDeadLetterSourceQueuesPages
func (mr *MockSQSClientMockRecorder) ListDeadLetterSourceQueuesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesPages", reflect.TypeOf((*MockSQSClient)(nil).ListDeadLetterSourceQueuesPages), arg0, arg1)
}

// ListDeadLetterSourceQueuesPagesWithContext mocks base method
func (m *MockSQSClient) ListDeadLetterSourceQueuesPagesWithContext(arg0 context.Context, arg1 *sqs.ListDeadLetterSourceQueuesInput, arg2 func(*sqs.ListDeadLetterSourceQueuesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDeadLetterSourceQueuesPagesWithContext indicates an expected call of ListDeadLetterSourceQueuesPagesWithContext
func (mr *MockSQSClientMockRecorder) ListDeadLetterSourceQueuesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesPagesWithContext", reflect.TypeOf((*MockSQSClient)(nil).ListDeadLetterSourceQueuesPagesWithContext), varargs...)
}

// ListDeadLetterSourceQueuesRequest mocks base method
func (m *MockSQSClient) ListDeadLetterSourceQueuesRequest(arg0 *sqs.ListDeadLetterSourceQueuesInput) (*request.Request, *sqs.ListDeadLetterSourceQueuesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ListDeadLetterSourceQueuesOutput)
	return ret0, ret1
}

// ListDeadLetterSourceQueuesRequest indicates an expected call of ListDeadLetterSourceQueuesRequest
func (mr *MockSQSClientMockRecorder) ListDeadLetterSourceQueuesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesRequest", reflect.TypeOf((*MockSQSClient)(nil).ListDeadLetterSourceQueuesRequest), arg0)
}

// ListDeadLetterSourceQueuesWithContext mocks base method
func (m *MockSQSClient) ListDeadLetterSourceQueuesWithContext(arg0 context.Context, arg1 *sqs.ListDeadLetterSourceQueuesInput, arg2 ...request.Option) (*sqs.ListDeadLetterSourceQueuesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDeadLetterSourceQueuesWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ListDeadLetterSourceQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeadLetterSourceQueuesWithContext indicates an expected call of ListDeadLetterSourceQueuesWithContext
func (mr *MockSQSClientMockRecorder) ListDeadLetterSourceQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesWithContext", reflect.TypeOf((*MockSQSClient)(nil).ListDeadLetterSourceQueuesWithContext), varargs...)
}

// ListQueueTags mocks base method
func (m *MockSQSClient) ListQueueTags(arg0 *sqs.ListQueueTagsInput) (*sqs.ListQueueTagsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueueTags", arg0)
	ret0, _ := ret[0].(*sqs.ListQueueTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueueTags indicates an expected call of ListQueueTags
func (mr *MockSQSClientMockRecorder) ListQueueTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTags", reflect.TypeOf((*MockSQSClient)(nil).ListQueueTags), arg0)
}

// ListQueueTagsRequest mocks base method
func (m *MockSQSClient) ListQueueTagsRequest(arg0 *sqs.ListQueueTagsInput) (*request.Request, *sqs.ListQueueTagsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueueTagsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ListQueueTagsOutput)
	return ret0, ret1
}

// ListQueueTagsRequest indicates an expected call of ListQueueTagsRequest
func (mr *MockSQSClientMockRecorder) ListQueueTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTagsRequest", reflect.TypeOf((*MockSQSClient)(nil).ListQueueTagsRequest), arg0)
}

// ListQueueTagsWithContext mocks base method
func (m *MockSQSClient) ListQueueTagsWithContext(arg0 context.Context, arg1 *sqs.ListQueueTagsInput, arg2 ...request.Option) (*sqs.ListQueueTagsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueueTagsWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ListQueueTagsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueueTagsWithContext indicates an expected call of ListQueueTagsWithContext
func (mr *MockSQSClientMockRecorder) ListQueueTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTagsWithContext", reflect.TypeOf((*MockSQSClient)(nil).ListQueueTagsWithContext), varargs...)
}

// ListQueues mocks base method
func (m *MockSQSClient) ListQueues(arg0 *sqs.ListQueuesInput) (*sqs.ListQueuesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueues", arg0)
	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueues indicates an expected call of ListQueues
func (mr *MockSQSClientMockRecorder) ListQueues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockSQSClient)(nil).ListQueues), arg0)
}

// ListQueuesPages mocks base method
func (m *MockSQSClient) ListQueuesPages(arg0 *sqs.ListQueuesInput, arg1 func(*sqs.ListQueuesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueuesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListQueuesPages indicates an expected call of ListQueuesPages
func (mr *MockSQSClientMockRecorder) ListQueuesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesPages", reflect.TypeOf((*MockSQSClient)(nil).ListQueuesPages), arg0, arg1)
}

// ListQueuesPagesWithContext mocks base method
func (m *MockSQSClient) ListQueuesPagesWithContext(arg0 context.Context, arg1 *sqs.ListQueuesInput, arg2 func(*sqs.ListQueuesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueuesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListQueuesPagesWithContext indicates an expected call of ListQueuesPagesWithContext
func (mr *MockSQSClientMockRecorder) ListQueuesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesPagesWithContext", reflect.TypeOf((*MockSQSClient)(nil).ListQueuesPagesWithContext), varargs...)
}

// ListQueuesRequest mocks base method
func (m *MockSQSClient) ListQueuesRequest(arg0 *sqs.ListQueuesInput) (*request.Request, *sqs.ListQueuesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueuesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ListQueuesOutput)
	return ret0, ret1
}

// ListQueuesRequest indicates an expected call of ListQueuesRequest
func (mr *MockSQSClientMockRecorder) ListQueuesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesRequest", reflect.TypeOf((*MockSQSClient)(nil).ListQueuesRequest), arg0)
}

// ListQueuesWithContext mocks base method
func (m *MockSQSClient) ListQueuesWithContext(arg0 context.Context, arg1 *sqs.ListQueuesInput, arg2 ...request.Option) (*sqs.ListQueuesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueuesWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ListQueuesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueuesWithContext indicates an expected call of ListQueuesWithContext
func (mr *MockSQSClientMockRecorder) ListQueuesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesWithContext", reflect.TypeOf((*MockSQSClient)(nil).ListQueuesWithContext), varargs...)
}

// PurgeQueue mocks base method
func (m *MockSQSClient) PurgeQueue(arg0 *sqs.PurgeQueueInput) (*sqs.PurgeQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeQueue", arg0)
	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeQueue indicates an expected call of PurgeQueue
func (mr *MockSQSClientMockRecorder) PurgeQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueue", reflect.TypeOf((*MockSQSClient)(nil).PurgeQueue), arg0)
}

// PurgeQueueRequest mocks base method
func (m *MockSQSClient) PurgeQueueRequest(arg0 *sqs.PurgeQueueInput) (*request.Request, *sqs.PurgeQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.PurgeQueueOutput)
	return ret0, ret1
}

// PurgeQueueRequest indicates an expected call of PurgeQueueRequest
func (mr *MockSQSClientMockRecorder) PurgeQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueRequest", reflect.TypeOf((*MockSQSClient)(nil).PurgeQueueRequest), arg0)
}

// PurgeQueueWithContext mocks base method
func (m *MockSQSClient) PurgeQueueWithContext(arg0 context.Context, arg1 *sqs.PurgeQueueInput, arg2 ...request.Option) (*sqs.PurgeQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgeQueueWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.PurgeQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeQueueWithContext indicates an expected call of PurgeQueueWithContext
func (mr *MockSQSClientMockRecorder) PurgeQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueWithContext", reflect.TypeOf((*MockSQSClient)(nil).PurgeQueueWithContext), varargs...)
}

// ReceiveMessage mocks base method
func (m *MockSQSClient) ReceiveMessage(arg0 *sqs.ReceiveMessageInput) (*sqs.ReceiveMessageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveMessage", arg0)
	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReceiveMessage indicates an expected call of ReceiveMessage
func (mr *MockSQSClientMockRecorder) ReceiveMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockSQSClient)(nil).ReceiveMessage), arg0)
}

// ReceiveMessageRequest mocks base method
func (m *MockSQSClient) ReceiveMessageRequest(arg0 *sqs.ReceiveMessageInput) (*request.Request, *sqs.ReceiveMessageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveMessageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.ReceiveMessageOutput)
	return ret0, ret1
}

// ReceiveMessageRequest indicates an expected call of ReceiveMessageRequest
func (mr *MockSQSClientMockRecorder) ReceiveMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageRequest", reflect.TypeOf((*MockSQSClient)(nil).ReceiveMessageRequest), arg0)
}

// ReceiveMessageWithContext mocks base method
func (m *MockSQSClient) ReceiveMessageWithContext(arg0 context.Context, arg1 *sqs.ReceiveMessageInput, arg2 ...request.Option) (*sqs.ReceiveMessageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReceiveMessageWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.ReceiveMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReceiveMessageWithContext indicates an expected call of ReceiveMessageWithContext
func (mr *MockSQSClientMockRecorder) ReceiveMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageWithContext", reflect.TypeOf((*MockSQSClient)(nil).ReceiveMessageWithContext), varargs...)
}

// RemovePermission mocks base method
func (m *MockSQSClient) RemovePermission(arg0 *sqs.RemovePermissionInput) (*sqs.RemovePermissionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermission", arg0)
	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemovePermission indicates an expected call of RemovePermission
func (mr *MockSQSClientMockRecorder) RemovePermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermission", reflect.TypeOf((*MockSQSClient)(nil).RemovePermission), arg0)
}

// RemovePermissionRequest mocks base method
func (m *MockSQSClient) RemovePermissionRequest(arg0 *sqs.RemovePermissionInput) (*request.Request, *sqs.RemovePermissionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.RemovePermissionOutput)
	return ret0, ret1
}

// RemovePermissionRequest indicates an expected call of RemovePermissionRequest
func (mr *MockSQSClientMockRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionRequest", reflect.TypeOf((*MockSQSClient)(nil).RemovePermissionRequest), arg0)
}

// RemovePermissionWithContext mocks base method
func (m *MockSQSClient) RemovePermissionWithContext(arg0 context.Context, arg1 *sqs.RemovePermissionInput, arg2 ...request.Option) (*sqs.RemovePermissionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemovePermissionWithContext indicates an expected call of RemovePermissionWithContext
func (mr *MockSQSClientMockRecorder) RemovePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionWithContext", reflect.TypeOf((*MockSQSClient)(nil).RemovePermissionWithContext), varargs...)
}

// SendMessage mocks base method
func (m *MockSQSClient) SendMessage(arg0 *sqs.SendMessageInput) (*sqs.SendMessageOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessage", arg0)
	ret0, _ := ret[0].(*sqs.SendMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessage indicates an expected call of SendMessage
func (mr *MockSQSClientMockRecorder) SendMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockSQSClient)(nil).SendMessage), arg0)
}

// SendMessageBatch mocks base method
func (m *MockSQSClient) SendMessageBatch(arg0 *sqs.SendMessageBatchInput) (*sqs.SendMessageBatchOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessageBatch", arg0)
	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessageBatch indicates an expected call of SendMessageBatch
func (mr *MockSQSClientMockRecorder) SendMessageBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatch", reflect.TypeOf((*MockSQSClient)(nil).SendMessageBatch), arg0)
}

// SendMessageBatchRequest mocks base method
func (m *MockSQSClient) SendMessageBatchRequest(arg0 *sqs.SendMessageBatchInput) (*request.Request, *sqs.SendMessageBatchOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessageBatchRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SendMessageBatchOutput)
	return ret0, ret1
}

// SendMessageBatchRequest indicates an expected call of SendMessageBatchRequest
func (mr *MockSQSClientMockRecorder) SendMessageBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchRequest", reflect.TypeOf((*MockSQSClient)(nil).SendMessageBatchRequest), arg0)
}

// SendMessageBatchWithContext mocks base method
func (m *MockSQSClient) SendMessageBatchWithContext(arg0 context.Context, arg1 *sqs.SendMessageBatchInput, arg2 ...request.Option) (*sqs.SendMessageBatchOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendMessageBatchWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.SendMessageBatchOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessageBatchWithContext indicates an expected call of SendMessageBatchWithContext
func (mr *MockSQSClientMockRecorder) SendMessageBatchWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchWithContext", reflect.TypeOf((*MockSQSClient)(nil).SendMessageBatchWithContext), varargs...)
}

// SendMessageRequest mocks base method
func (m *MockSQSClient) SendMessageRequest(arg0 *sqs.SendMessageInput) (*request.Request, *sqs.SendMessageOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessageRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SendMessageOutput)
	return ret0, ret1
}

// SendMessageRequest indicates an expected call of SendMessageRequest
func (mr *MockSQSClientMockRecorder) SendMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageRequest", reflect.TypeOf((*MockSQSClient)(nil).SendMessageRequest), arg0)
}

// SendMessageWithContext mocks base method
func (m *MockSQSClient) SendMessageWithContext(arg0 context.Context, arg1 *sqs.SendMessageInput, arg2 ...request.Option) (*sqs.SendMessageOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendMessageWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.SendMessageOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessageWithContext indicates an expected call of SendMessageWithContext
func (mr *MockSQSClientMockRecorder) SendMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageWithContext", reflect.TypeOf((*MockSQSClient)(nil).SendMessageWithContext), varargs...)
}

// SetQueueAttributes mocks base method
func (m *MockSQSClient) SetQueueAttributes(arg0 *sqs.SetQueueAttributesInput) (*sqs.SetQueueAttributesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetQueueAttributes", arg0)
	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetQueueAttributes indicates an expected call of SetQueueAttributes
func (mr *MockSQSClientMockRecorder) SetQueueAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributes", reflect.TypeOf((*MockSQSClient)(nil).SetQueueAttributes), arg0)
}

// SetQueueAttributesRequest mocks base method
func (m *MockSQSClient) SetQueueAttributesRequest(arg0 *sqs.SetQueueAttributesInput) (*request.Request, *sqs.SetQueueAttributesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetQueueAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.SetQueueAttributesOutput)
	return ret0, ret1
}

// SetQueueAttributesRequest indicates an expected call of SetQueueAttributesRequest
func (mr *MockSQSClientMockRecorder) SetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesRequest", reflect.TypeOf((*MockSQSClient)(nil).SetQueueAttributesRequest), arg0)
}

// SetQueueAttributesWithContext mocks base method
func (m *MockSQSClient) SetQueueAttributesWithContext(arg0 context.Context, arg1 *sqs.SetQueueAttributesInput, arg2 ...request.Option) (*sqs.SetQueueAttributesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetQueueAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.SetQueueAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetQueueAttributesWithContext indicates an expected call of SetQueueAttributesWithContext
func (mr *MockSQSClientMockRecorder) SetQueueAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesWithContext", reflect.TypeOf((*MockSQSClient)(nil).SetQueueAttributesWithContext), varargs...)
}

// TagQueue mocks base method
func (m *MockSQSClient) TagQueue(arg0 *sqs.TagQueueInput) (*sqs.TagQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagQueue", arg0)
	ret0, _ := ret[0].(*sqs.TagQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagQueue indicates an expected call of TagQueue
func (mr *MockSQSClientMockRecorder) TagQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueue", reflect.TypeOf((*MockSQSClient)(nil).TagQueue), arg0)
}

// TagQueueRequest mocks base method
func (m *MockSQSClient) TagQueueRequest(arg0 *sqs.TagQueueInput) (*request.Request, *sqs.TagQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.TagQueueOutput)
	return ret0, ret1
}

// TagQueueRequest indicates an expected call of TagQueueRequest
func (mr *MockSQSClientMockRecorder) TagQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueueRequest", reflect.TypeOf((*MockSQSClient)(nil).TagQueueRequest), arg0)
}

// TagQueueWithContext mocks base method
func (m *MockSQSClient) TagQueueWithContext(arg0 context.Context, arg1 *sqs.TagQueueInput, arg2 ...request.Option) (*sqs.TagQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TagQueueWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.TagQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagQueueWithContext indicates an expected call of TagQueueWithContext
func (mr *MockSQSClientMockRecorder) TagQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueueWithContext", reflect.TypeOf((*MockSQSClient)(nil).TagQueueWithContext), varargs...)
}

// UntagQueue mocks base method
func (m *MockSQSClient) UntagQueue(arg0 *sqs.UntagQueueInput) (*sqs.UntagQueueOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagQueue", arg0)
	ret0, _ := ret[0].(*sqs.UntagQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagQueue indicates an expected call of UntagQueue
func (mr *MockSQSClientMockRecorder) UntagQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueue", reflect.TypeOf((*MockSQSClient)(nil).UntagQueue), arg0)
}

// UntagQueueRequest mocks base method
func (m *MockSQSClient) UntagQueueRequest(arg0 *sqs.UntagQueueInput) (*request.Request, *sqs.UntagQueueOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagQueueRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sqs.UntagQueueOutput)
	return ret0, ret1
}

// UntagQueueRequest indicates an expected call of UntagQueueRequest
func (mr *MockSQSClientMockRecorder) UntagQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueueRequest", reflect.TypeOf((*MockSQSClient)(nil).UntagQueueRequest), arg0)
}

// UntagQueueWithContext mocks base method
func (m *MockSQSClient) UntagQueueWithContext(arg0 context.Context, arg1 *sqs.UntagQueueInput, arg2 ...request.Option) (*sqs.UntagQueueOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UntagQueueWithContext", varargs...)
	ret0, _ := ret[0].(*sqs.UntagQueueOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagQueueWithContext indicates an expected call of UntagQueueWithContext
func (mr *MockSQSClientMockRecorder) UntagQueueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueueWithContext", reflect.TypeOf((*MockSQSClient)(nil).UntagQueueWithContext), varargs...)
}
