sigs.k8s.io/cluster-api-provider-aws@v1.5.5/pkg/cloud/services/instancestate/mock_sqsiface/sqsiface_mock.go

/*
Copyright The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

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

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

import (
	context "context"
	reflect "reflect"

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

// MockSQSAPI is a mock of SQSAPI interface.
type MockSQSAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSQSAPIMockRecorder
}

// MockSQSAPIMockRecorder is the mock recorder for MockSQSAPI.
type MockSQSAPIMockRecorder struct {
	mock *MockSQSAPI
}

// NewMockSQSAPI creates a new mock instance.
func NewMockSQSAPI(ctrl *gomock.Controller) *MockSQSAPI {
	mock := &MockSQSAPI{ctrl: ctrl}
	mock.recorder = &MockSQSAPIMockRecorder{mock}
	return mock
}

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

// AddPermission mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) AddPermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermission", reflect.TypeOf((*MockSQSAPI)(nil).AddPermission), arg0)
}

// AddPermissionRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) AddPermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).AddPermissionRequest), arg0)
}

// AddPermissionWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).AddPermissionWithContext), varargs...)
}

// ChangeMessageVisibility mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ChangeMessageVisibility(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibility", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibility), arg0)
}

// ChangeMessageVisibilityBatch mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatch", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatch), arg0)
}

// ChangeMessageVisibilityBatchRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ChangeMessageVisibilityBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchRequest), arg0)
}

// ChangeMessageVisibilityBatchWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ChangeMessageVisibilityBatchWithContext), varargs...)
}

// ChangeMessageVisibilityRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ChangeMessageVisibilityRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeMessageVisibilityRequest", reflect.TypeOf((*MockSQSAPI)(nil).ChangeMessageVisibilityRequest), arg0)
}

// ChangeMessageVisibilityWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ChangeMessageVisibilityWithContext), varargs...)
}

// CreateQueue mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) CreateQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueue), arg0)
}

// CreateQueueRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) CreateQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).CreateQueueRequest), arg0)
}

// CreateQueueWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).CreateQueueWithContext), varargs...)
}

// DeleteMessage mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessage", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessage), arg0)
}

// DeleteMessageBatch mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteMessageBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatch), arg0)
}

// DeleteMessageBatchRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteMessageBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageBatchRequest), arg0)
}

// DeleteMessageBatchWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).DeleteMessageBatchWithContext), varargs...)
}

// DeleteMessageRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteMessageRequest), arg0)
}

// DeleteMessageWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).DeleteMessageWithContext), varargs...)
}

// DeleteQueue mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueue", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueue), arg0)
}

// DeleteQueueRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) DeleteQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).DeleteQueueRequest), arg0)
}

// DeleteQueueWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).DeleteQueueWithContext), varargs...)
}

// GetQueueAttributes mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) GetQueueAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributes), arg0)
}

// GetQueueAttributesRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) GetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueAttributesRequest), arg0)
}

// GetQueueAttributesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).GetQueueAttributesWithContext), varargs...)
}

// GetQueueUrl mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) GetQueueUrl(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrl", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrl), arg0)
}

// GetQueueUrlRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) GetQueueUrlRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueUrlRequest", reflect.TypeOf((*MockSQSAPI)(nil).GetQueueUrlRequest), arg0)
}

// GetQueueUrlWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).GetQueueUrlWithContext), varargs...)
}

// ListDeadLetterSourceQueues mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListDeadLetterSourceQueues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueues), arg0)
}

// ListDeadLetterSourceQueuesPages mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesPages", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesPages), arg0, arg1)
}

// ListDeadLetterSourceQueuesPagesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesPagesWithContext), varargs...)
}

// ListDeadLetterSourceQueuesRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListDeadLetterSourceQueuesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeadLetterSourceQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesRequest), arg0)
}

// ListDeadLetterSourceQueuesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ListDeadLetterSourceQueuesWithContext), varargs...)
}

// ListQueueTags mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListQueueTags(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTags", reflect.TypeOf((*MockSQSAPI)(nil).ListQueueTags), arg0)
}

// ListQueueTagsRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListQueueTagsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueueTagsRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListQueueTagsRequest), arg0)
}

// ListQueueTagsWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ListQueueTagsWithContext), varargs...)
}

// ListQueues mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListQueues(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockSQSAPI)(nil).ListQueues), arg0)
}

// ListQueuesPages mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListQueuesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesPages", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesPages), arg0, arg1)
}

// ListQueuesPagesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ListQueuesPagesWithContext), varargs...)
}

// ListQueuesRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ListQueuesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueuesRequest", reflect.TypeOf((*MockSQSAPI)(nil).ListQueuesRequest), arg0)
}

// ListQueuesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ListQueuesWithContext), varargs...)
}

// PurgeQueue mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) PurgeQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueue", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueue), arg0)
}

// PurgeQueueRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) PurgeQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).PurgeQueueRequest), arg0)
}

// PurgeQueueWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).PurgeQueueWithContext), varargs...)
}

// ReceiveMessage mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ReceiveMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessage), arg0)
}

// ReceiveMessageRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) ReceiveMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).ReceiveMessageRequest), arg0)
}

// ReceiveMessageWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).ReceiveMessageWithContext), varargs...)
}

// RemovePermission mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) RemovePermission(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermission", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermission), arg0)
}

// RemovePermissionRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) RemovePermissionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePermissionRequest", reflect.TypeOf((*MockSQSAPI)(nil).RemovePermissionRequest), arg0)
}

// RemovePermissionWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).RemovePermissionWithContext), varargs...)
}

// SendMessage mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SendMessage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockSQSAPI)(nil).SendMessage), arg0)
}

// SendMessageBatch mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SendMessageBatch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatch", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatch), arg0)
}

// SendMessageBatchRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SendMessageBatchRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageBatchRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageBatchRequest), arg0)
}

// SendMessageBatchWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).SendMessageBatchWithContext), varargs...)
}

// SendMessageRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SendMessageRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessageRequest", reflect.TypeOf((*MockSQSAPI)(nil).SendMessageRequest), arg0)
}

// SendMessageWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).SendMessageWithContext), varargs...)
}

// SetQueueAttributes mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SetQueueAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributes", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributes), arg0)
}

// SetQueueAttributesRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) SetQueueAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetQueueAttributesRequest", reflect.TypeOf((*MockSQSAPI)(nil).SetQueueAttributesRequest), arg0)
}

// SetQueueAttributesWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).SetQueueAttributesWithContext), varargs...)
}

// TagQueue mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) TagQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueue", reflect.TypeOf((*MockSQSAPI)(nil).TagQueue), arg0)
}

// TagQueueRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) TagQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).TagQueueRequest), arg0)
}

// TagQueueWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).TagQueueWithContext), varargs...)
}

// UntagQueue mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) UntagQueue(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueue", reflect.TypeOf((*MockSQSAPI)(nil).UntagQueue), arg0)
}

// UntagQueueRequest mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) UntagQueueRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagQueueRequest", reflect.TypeOf((*MockSQSAPI)(nil).UntagQueueRequest), arg0)
}

// UntagQueueWithContext mocks base method.
func (m *MockSQSAPI) 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 *MockSQSAPIMockRecorder) 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((*MockSQSAPI)(nil).UntagQueueWithContext), varargs...)
}