snsapi.go

// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go

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

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

// MockSNSAPI is a mock of SNSAPI interface
type MockSNSAPI struct {
	ctrl     *gomock.Controller
	recorder *MockSNSAPIMockRecorder
}

// MockSNSAPIMockRecorder is the mock recorder for MockSNSAPI
type MockSNSAPIMockRecorder struct {
	mock *MockSNSAPI
}

// NewMockSNSAPI creates a new mock instance
func NewMockSNSAPI(ctrl *gomock.Controller) *MockSNSAPI {
	mock := &MockSNSAPI{ctrl: ctrl}
	mock.recorder = &MockSNSAPIMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// CheckIfPhoneNumberIsOptedOut mocks base method
func (m *MockSNSAPI) CheckIfPhoneNumberIsOptedOut(arg0 *sns.CheckIfPhoneNumberIsOptedOutInput) (*sns.CheckIfPhoneNumberIsOptedOutOutput, error) {
	ret := m.ctrl.Call(m, "CheckIfPhoneNumberIsOptedOut", arg0)
	ret0, _ := ret[0].(*sns.CheckIfPhoneNumberIsOptedOutOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckIfPhoneNumberIsOptedOut indicates an expected call of CheckIfPhoneNumberIsOptedOut
func (mr *MockSNSAPIMockRecorder) CheckIfPhoneNumberIsOptedOut(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckIfPhoneNumberIsOptedOut", reflect.TypeOf((*MockSNSAPI)(nil).CheckIfPhoneNumberIsOptedOut), arg0)
}

// CheckIfPhoneNumberIsOptedOutWithContext mocks base method
func (m *MockSNSAPI) CheckIfPhoneNumberIsOptedOutWithContext(arg0 aws.Context, arg1 *sns.CheckIfPhoneNumberIsOptedOutInput, arg2 ...request.Option) (*sns.CheckIfPhoneNumberIsOptedOutOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckIfPhoneNumberIsOptedOutWithContext", varargs...)
	ret0, _ := ret[0].(*sns.CheckIfPhoneNumberIsOptedOutOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckIfPhoneNumberIsOptedOutRequest mocks base method
func (m *MockSNSAPI) CheckIfPhoneNumberIsOptedOutRequest(arg0 *sns.CheckIfPhoneNumberIsOptedOutInput) (*request.Request, *sns.CheckIfPhoneNumberIsOptedOutOutput) {
	ret := m.ctrl.Call(m, "CheckIfPhoneNumberIsOptedOutRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.CheckIfPhoneNumberIsOptedOutOutput)
	return ret0, ret1
}

// CheckIfPhoneNumberIsOptedOutRequest indicates an expected call of CheckIfPhoneNumberIsOptedOutRequest
func (mr *MockSNSAPIMockRecorder) CheckIfPhoneNumberIsOptedOutRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckIfPhoneNumberIsOptedOutRequest", reflect.TypeOf((*MockSNSAPI)(nil).CheckIfPhoneNumberIsOptedOutRequest), arg0)
}

// ConfirmSubscription mocks base method
func (m *MockSNSAPI) ConfirmSubscription(arg0 *sns.ConfirmSubscriptionInput) (*sns.ConfirmSubscriptionOutput, error) {
	ret := m.ctrl.Call(m, "ConfirmSubscription", arg0)
	ret0, _ := ret[0].(*sns.ConfirmSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConfirmSubscription indicates an expected call of ConfirmSubscription
func (mr *MockSNSAPIMockRecorder) ConfirmSubscription(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSubscription", reflect.TypeOf((*MockSNSAPI)(nil).ConfirmSubscription), arg0)
}

// ConfirmSubscriptionWithContext mocks base method
func (m *MockSNSAPI) ConfirmSubscriptionWithContext(arg0 aws.Context, arg1 *sns.ConfirmSubscriptionInput, arg2 ...request.Option) (*sns.ConfirmSubscriptionOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ConfirmSubscriptionWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ConfirmSubscriptionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConfirmSubscriptionRequest mocks base method
func (m *MockSNSAPI) ConfirmSubscriptionRequest(arg0 *sns.ConfirmSubscriptionInput) (*request.Request, *sns.ConfirmSubscriptionOutput) {
	ret := m.ctrl.Call(m, "ConfirmSubscriptionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ConfirmSubscriptionOutput)
	return ret0, ret1
}

// ConfirmSubscriptionRequest indicates an expected call of ConfirmSubscriptionRequest
func (mr *MockSNSAPIMockRecorder) ConfirmSubscriptionRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSubscriptionRequest", reflect.TypeOf((*MockSNSAPI)(nil).ConfirmSubscriptionRequest), arg0)
}

// CreatePlatformApplication mocks base method
func (m *MockSNSAPI) CreatePlatformApplication(arg0 *sns.CreatePlatformApplicationInput) (*sns.CreatePlatformApplicationOutput, error) {
	ret := m.ctrl.Call(m, "CreatePlatformApplication", arg0)
	ret0, _ := ret[0].(*sns.CreatePlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePlatformApplication indicates an expected call of CreatePlatformApplication
func (mr *MockSNSAPIMockRecorder) CreatePlatformApplication(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformApplication", reflect.TypeOf((*MockSNSAPI)(nil).CreatePlatformApplication), arg0)
}

// CreatePlatformApplicationWithContext mocks base method
func (m *MockSNSAPI) CreatePlatformApplicationWithContext(arg0 aws.Context, arg1 *sns.CreatePlatformApplicationInput, arg2 ...request.Option) (*sns.CreatePlatformApplicationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePlatformApplicationWithContext", varargs...)
	ret0, _ := ret[0].(*sns.CreatePlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlatformApplicationRequest mocks base method
func (m *MockSNSAPI) CreatePlatformApplicationRequest(arg0 *sns.CreatePlatformApplicationInput) (*request.Request, *sns.CreatePlatformApplicationOutput) {
	ret := m.ctrl.Call(m, "CreatePlatformApplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.CreatePlatformApplicationOutput)
	return ret0, ret1
}

// CreatePlatformApplicationRequest indicates an expected call of CreatePlatformApplicationRequest
func (mr *MockSNSAPIMockRecorder) CreatePlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformApplicationRequest", reflect.TypeOf((*MockSNSAPI)(nil).CreatePlatformApplicationRequest), arg0)
}

// CreatePlatformEndpoint mocks base method
func (m *MockSNSAPI) CreatePlatformEndpoint(arg0 *sns.CreatePlatformEndpointInput) (*sns.CreatePlatformEndpointOutput, error) {
	ret := m.ctrl.Call(m, "CreatePlatformEndpoint", arg0)
	ret0, _ := ret[0].(*sns.CreatePlatformEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePlatformEndpoint indicates an expected call of CreatePlatformEndpoint
func (mr *MockSNSAPIMockRecorder) CreatePlatformEndpoint(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformEndpoint", reflect.TypeOf((*MockSNSAPI)(nil).CreatePlatformEndpoint), arg0)
}

// CreatePlatformEndpointWithContext mocks base method
func (m *MockSNSAPI) CreatePlatformEndpointWithContext(arg0 aws.Context, arg1 *sns.CreatePlatformEndpointInput, arg2 ...request.Option) (*sns.CreatePlatformEndpointOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePlatformEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*sns.CreatePlatformEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePlatformEndpointRequest mocks base method
func (m *MockSNSAPI) CreatePlatformEndpointRequest(arg0 *sns.CreatePlatformEndpointInput) (*request.Request, *sns.CreatePlatformEndpointOutput) {
	ret := m.ctrl.Call(m, "CreatePlatformEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.CreatePlatformEndpointOutput)
	return ret0, ret1
}

// CreatePlatformEndpointRequest indicates an expected call of CreatePlatformEndpointRequest
func (mr *MockSNSAPIMockRecorder) CreatePlatformEndpointRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformEndpointRequest", reflect.TypeOf((*MockSNSAPI)(nil).CreatePlatformEndpointRequest), arg0)
}

// CreateTopic mocks base method
func (m *MockSNSAPI) CreateTopic(arg0 *sns.CreateTopicInput) (*sns.CreateTopicOutput, error) {
	ret := m.ctrl.Call(m, "CreateTopic", arg0)
	ret0, _ := ret[0].(*sns.CreateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTopic indicates an expected call of CreateTopic
func (mr *MockSNSAPIMockRecorder) CreateTopic(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopic", reflect.TypeOf((*MockSNSAPI)(nil).CreateTopic), arg0)
}

// CreateTopicWithContext mocks base method
func (m *MockSNSAPI) CreateTopicWithContext(arg0 aws.Context, arg1 *sns.CreateTopicInput, arg2 ...request.Option) (*sns.CreateTopicOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTopicWithContext", varargs...)
	ret0, _ := ret[0].(*sns.CreateTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTopicRequest mocks base method
func (m *MockSNSAPI) CreateTopicRequest(arg0 *sns.CreateTopicInput) (*request.Request, *sns.CreateTopicOutput) {
	ret := m.ctrl.Call(m, "CreateTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.CreateTopicOutput)
	return ret0, ret1
}

// CreateTopicRequest indicates an expected call of CreateTopicRequest
func (mr *MockSNSAPIMockRecorder) CreateTopicRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopicRequest", reflect.TypeOf((*MockSNSAPI)(nil).CreateTopicRequest), arg0)
}

// DeleteEndpoint mocks base method
func (m *MockSNSAPI) DeleteEndpoint(arg0 *sns.DeleteEndpointInput) (*sns.DeleteEndpointOutput, error) {
	ret := m.ctrl.Call(m, "DeleteEndpoint", arg0)
	ret0, _ := ret[0].(*sns.DeleteEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteEndpoint indicates an expected call of DeleteEndpoint
func (mr *MockSNSAPIMockRecorder) DeleteEndpoint(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpoint", reflect.TypeOf((*MockSNSAPI)(nil).DeleteEndpoint), arg0)
}

// DeleteEndpointWithContext mocks base method
func (m *MockSNSAPI) DeleteEndpointWithContext(arg0 aws.Context, arg1 *sns.DeleteEndpointInput, arg2 ...request.Option) (*sns.DeleteEndpointOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteEndpointWithContext", varargs...)
	ret0, _ := ret[0].(*sns.DeleteEndpointOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEndpointRequest mocks base method
func (m *MockSNSAPI) DeleteEndpointRequest(arg0 *sns.DeleteEndpointInput) (*request.Request, *sns.DeleteEndpointOutput) {
	ret := m.ctrl.Call(m, "DeleteEndpointRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.DeleteEndpointOutput)
	return ret0, ret1
}

// DeleteEndpointRequest indicates an expected call of DeleteEndpointRequest
func (mr *MockSNSAPIMockRecorder) DeleteEndpointRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpointRequest", reflect.TypeOf((*MockSNSAPI)(nil).DeleteEndpointRequest), arg0)
}

// DeletePlatformApplication mocks base method
func (m *MockSNSAPI) DeletePlatformApplication(arg0 *sns.DeletePlatformApplicationInput) (*sns.DeletePlatformApplicationOutput, error) {
	ret := m.ctrl.Call(m, "DeletePlatformApplication", arg0)
	ret0, _ := ret[0].(*sns.DeletePlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePlatformApplication indicates an expected call of DeletePlatformApplication
func (mr *MockSNSAPIMockRecorder) DeletePlatformApplication(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlatformApplication", reflect.TypeOf((*MockSNSAPI)(nil).DeletePlatformApplication), arg0)
}

// DeletePlatformApplicationWithContext mocks base method
func (m *MockSNSAPI) DeletePlatformApplicationWithContext(arg0 aws.Context, arg1 *sns.DeletePlatformApplicationInput, arg2 ...request.Option) (*sns.DeletePlatformApplicationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePlatformApplicationWithContext", varargs...)
	ret0, _ := ret[0].(*sns.DeletePlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePlatformApplicationRequest mocks base method
func (m *MockSNSAPI) DeletePlatformApplicationRequest(arg0 *sns.DeletePlatformApplicationInput) (*request.Request, *sns.DeletePlatformApplicationOutput) {
	ret := m.ctrl.Call(m, "DeletePlatformApplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.DeletePlatformApplicationOutput)
	return ret0, ret1
}

// DeletePlatformApplicationRequest indicates an expected call of DeletePlatformApplicationRequest
func (mr *MockSNSAPIMockRecorder) DeletePlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlatformApplicationRequest", reflect.TypeOf((*MockSNSAPI)(nil).DeletePlatformApplicationRequest), arg0)
}

// DeleteTopic mocks base method
func (m *MockSNSAPI) DeleteTopic(arg0 *sns.DeleteTopicInput) (*sns.DeleteTopicOutput, error) {
	ret := m.ctrl.Call(m, "DeleteTopic", arg0)
	ret0, _ := ret[0].(*sns.DeleteTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTopic indicates an expected call of DeleteTopic
func (mr *MockSNSAPIMockRecorder) DeleteTopic(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopic", reflect.TypeOf((*MockSNSAPI)(nil).DeleteTopic), arg0)
}

// DeleteTopicWithContext mocks base method
func (m *MockSNSAPI) DeleteTopicWithContext(arg0 aws.Context, arg1 *sns.DeleteTopicInput, arg2 ...request.Option) (*sns.DeleteTopicOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTopicWithContext", varargs...)
	ret0, _ := ret[0].(*sns.DeleteTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTopicRequest mocks base method
func (m *MockSNSAPI) DeleteTopicRequest(arg0 *sns.DeleteTopicInput) (*request.Request, *sns.DeleteTopicOutput) {
	ret := m.ctrl.Call(m, "DeleteTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.DeleteTopicOutput)
	return ret0, ret1
}

// DeleteTopicRequest indicates an expected call of DeleteTopicRequest
func (mr *MockSNSAPIMockRecorder) DeleteTopicRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopicRequest", reflect.TypeOf((*MockSNSAPI)(nil).DeleteTopicRequest), arg0)
}

// GetEndpointAttributes mocks base method
func (m *MockSNSAPI) GetEndpointAttributes(arg0 *sns.GetEndpointAttributesInput) (*sns.GetEndpointAttributesOutput, error) {
	ret := m.ctrl.Call(m, "GetEndpointAttributes", arg0)
	ret0, _ := ret[0].(*sns.GetEndpointAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEndpointAttributes indicates an expected call of GetEndpointAttributes
func (mr *MockSNSAPIMockRecorder) GetEndpointAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointAttributes", reflect.TypeOf((*MockSNSAPI)(nil).GetEndpointAttributes), arg0)
}

// GetEndpointAttributesWithContext mocks base method
func (m *MockSNSAPI) GetEndpointAttributesWithContext(arg0 aws.Context, arg1 *sns.GetEndpointAttributesInput, arg2 ...request.Option) (*sns.GetEndpointAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEndpointAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.GetEndpointAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEndpointAttributesRequest mocks base method
func (m *MockSNSAPI) GetEndpointAttributesRequest(arg0 *sns.GetEndpointAttributesInput) (*request.Request, *sns.GetEndpointAttributesOutput) {
	ret := m.ctrl.Call(m, "GetEndpointAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.GetEndpointAttributesOutput)
	return ret0, ret1
}

// GetEndpointAttributesRequest indicates an expected call of GetEndpointAttributesRequest
func (mr *MockSNSAPIMockRecorder) GetEndpointAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).GetEndpointAttributesRequest), arg0)
}

// GetPlatformApplicationAttributes mocks base method
func (m *MockSNSAPI) GetPlatformApplicationAttributes(arg0 *sns.GetPlatformApplicationAttributesInput) (*sns.GetPlatformApplicationAttributesOutput, error) {
	ret := m.ctrl.Call(m, "GetPlatformApplicationAttributes", arg0)
	ret0, _ := ret[0].(*sns.GetPlatformApplicationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPlatformApplicationAttributes indicates an expected call of GetPlatformApplicationAttributes
func (mr *MockSNSAPIMockRecorder) GetPlatformApplicationAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlatformApplicationAttributes", reflect.TypeOf((*MockSNSAPI)(nil).GetPlatformApplicationAttributes), arg0)
}

// GetPlatformApplicationAttributesWithContext mocks base method
func (m *MockSNSAPI) GetPlatformApplicationAttributesWithContext(arg0 aws.Context, arg1 *sns.GetPlatformApplicationAttributesInput, arg2 ...request.Option) (*sns.GetPlatformApplicationAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPlatformApplicationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.GetPlatformApplicationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPlatformApplicationAttributesRequest mocks base method
func (m *MockSNSAPI) GetPlatformApplicationAttributesRequest(arg0 *sns.GetPlatformApplicationAttributesInput) (*request.Request, *sns.GetPlatformApplicationAttributesOutput) {
	ret := m.ctrl.Call(m, "GetPlatformApplicationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.GetPlatformApplicationAttributesOutput)
	return ret0, ret1
}

// GetPlatformApplicationAttributesRequest indicates an expected call of GetPlatformApplicationAttributesRequest
func (mr *MockSNSAPIMockRecorder) GetPlatformApplicationAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlatformApplicationAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).GetPlatformApplicationAttributesRequest), arg0)
}

// GetSMSAttributes mocks base method
func (m *MockSNSAPI) GetSMSAttributes(arg0 *sns.GetSMSAttributesInput) (*sns.GetSMSAttributesOutput, error) {
	ret := m.ctrl.Call(m, "GetSMSAttributes", arg0)
	ret0, _ := ret[0].(*sns.GetSMSAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSMSAttributes indicates an expected call of GetSMSAttributes
func (mr *MockSNSAPIMockRecorder) GetSMSAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSMSAttributes", reflect.TypeOf((*MockSNSAPI)(nil).GetSMSAttributes), arg0)
}

// GetSMSAttributesWithContext mocks base method
func (m *MockSNSAPI) GetSMSAttributesWithContext(arg0 aws.Context, arg1 *sns.GetSMSAttributesInput, arg2 ...request.Option) (*sns.GetSMSAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSMSAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.GetSMSAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSMSAttributesRequest mocks base method
func (m *MockSNSAPI) GetSMSAttributesRequest(arg0 *sns.GetSMSAttributesInput) (*request.Request, *sns.GetSMSAttributesOutput) {
	ret := m.ctrl.Call(m, "GetSMSAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.GetSMSAttributesOutput)
	return ret0, ret1
}

// GetSMSAttributesRequest indicates an expected call of GetSMSAttributesRequest
func (mr *MockSNSAPIMockRecorder) GetSMSAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSMSAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).GetSMSAttributesRequest), arg0)
}

// GetSubscriptionAttributes mocks base method
func (m *MockSNSAPI) GetSubscriptionAttributes(arg0 *sns.GetSubscriptionAttributesInput) (*sns.GetSubscriptionAttributesOutput, error) {
	ret := m.ctrl.Call(m, "GetSubscriptionAttributes", arg0)
	ret0, _ := ret[0].(*sns.GetSubscriptionAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptionAttributes indicates an expected call of GetSubscriptionAttributes
func (mr *MockSNSAPIMockRecorder) GetSubscriptionAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionAttributes", reflect.TypeOf((*MockSNSAPI)(nil).GetSubscriptionAttributes), arg0)
}

// GetSubscriptionAttributesWithContext mocks base method
func (m *MockSNSAPI) GetSubscriptionAttributesWithContext(arg0 aws.Context, arg1 *sns.GetSubscriptionAttributesInput, arg2 ...request.Option) (*sns.GetSubscriptionAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubscriptionAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.GetSubscriptionAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSubscriptionAttributesRequest mocks base method
func (m *MockSNSAPI) GetSubscriptionAttributesRequest(arg0 *sns.GetSubscriptionAttributesInput) (*request.Request, *sns.GetSubscriptionAttributesOutput) {
	ret := m.ctrl.Call(m, "GetSubscriptionAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.GetSubscriptionAttributesOutput)
	return ret0, ret1
}

// GetSubscriptionAttributesRequest indicates an expected call of GetSubscriptionAttributesRequest
func (mr *MockSNSAPIMockRecorder) GetSubscriptionAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).GetSubscriptionAttributesRequest), arg0)
}

// GetTopicAttributes mocks base method
func (m *MockSNSAPI) GetTopicAttributes(arg0 *sns.GetTopicAttributesInput) (*sns.GetTopicAttributesOutput, error) {
	ret := m.ctrl.Call(m, "GetTopicAttributes", arg0)
	ret0, _ := ret[0].(*sns.GetTopicAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTopicAttributes indicates an expected call of GetTopicAttributes
func (mr *MockSNSAPIMockRecorder) GetTopicAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopicAttributes", reflect.TypeOf((*MockSNSAPI)(nil).GetTopicAttributes), arg0)
}

// GetTopicAttributesWithContext mocks base method
func (m *MockSNSAPI) GetTopicAttributesWithContext(arg0 aws.Context, arg1 *sns.GetTopicAttributesInput, arg2 ...request.Option) (*sns.GetTopicAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTopicAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.GetTopicAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTopicAttributesRequest mocks base method
func (m *MockSNSAPI) GetTopicAttributesRequest(arg0 *sns.GetTopicAttributesInput) (*request.Request, *sns.GetTopicAttributesOutput) {
	ret := m.ctrl.Call(m, "GetTopicAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.GetTopicAttributesOutput)
	return ret0, ret1
}

// GetTopicAttributesRequest indicates an expected call of GetTopicAttributesRequest
func (mr *MockSNSAPIMockRecorder) GetTopicAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopicAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).GetTopicAttributesRequest), arg0)
}

// ListEndpointsByPlatformApplication mocks base method
func (m *MockSNSAPI) ListEndpointsByPlatformApplication(arg0 *sns.ListEndpointsByPlatformApplicationInput) (*sns.ListEndpointsByPlatformApplicationOutput, error) {
	ret := m.ctrl.Call(m, "ListEndpointsByPlatformApplication", arg0)
	ret0, _ := ret[0].(*sns.ListEndpointsByPlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEndpointsByPlatformApplication indicates an expected call of ListEndpointsByPlatformApplication
func (mr *MockSNSAPIMockRecorder) ListEndpointsByPlatformApplication(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsByPlatformApplication", reflect.TypeOf((*MockSNSAPI)(nil).ListEndpointsByPlatformApplication), arg0)
}

// ListEndpointsByPlatformApplicationWithContext mocks base method
func (m *MockSNSAPI) ListEndpointsByPlatformApplicationWithContext(arg0 aws.Context, arg1 *sns.ListEndpointsByPlatformApplicationInput, arg2 ...request.Option) (*sns.ListEndpointsByPlatformApplicationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEndpointsByPlatformApplicationWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListEndpointsByPlatformApplicationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEndpointsByPlatformApplicationRequest mocks base method
func (m *MockSNSAPI) ListEndpointsByPlatformApplicationRequest(arg0 *sns.ListEndpointsByPlatformApplicationInput) (*request.Request, *sns.ListEndpointsByPlatformApplicationOutput) {
	ret := m.ctrl.Call(m, "ListEndpointsByPlatformApplicationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListEndpointsByPlatformApplicationOutput)
	return ret0, ret1
}

// ListEndpointsByPlatformApplicationRequest indicates an expected call of ListEndpointsByPlatformApplicationRequest
func (mr *MockSNSAPIMockRecorder) ListEndpointsByPlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsByPlatformApplicationRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListEndpointsByPlatformApplicationRequest), arg0)
}

// ListEndpointsByPlatformApplicationPages mocks base method
func (m *MockSNSAPI) ListEndpointsByPlatformApplicationPages(arg0 *sns.ListEndpointsByPlatformApplicationInput, arg1 func(*sns.ListEndpointsByPlatformApplicationOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListEndpointsByPlatformApplicationPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointsByPlatformApplicationPages indicates an expected call of ListEndpointsByPlatformApplicationPages
func (mr *MockSNSAPIMockRecorder) ListEndpointsByPlatformApplicationPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsByPlatformApplicationPages", reflect.TypeOf((*MockSNSAPI)(nil).ListEndpointsByPlatformApplicationPages), arg0, arg1)
}

// ListEndpointsByPlatformApplicationPagesWithContext mocks base method
func (m *MockSNSAPI) ListEndpointsByPlatformApplicationPagesWithContext(arg0 aws.Context, arg1 *sns.ListEndpointsByPlatformApplicationInput, arg2 func(*sns.ListEndpointsByPlatformApplicationOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEndpointsByPlatformApplicationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPhoneNumbersOptedOut mocks base method
func (m *MockSNSAPI) ListPhoneNumbersOptedOut(arg0 *sns.ListPhoneNumbersOptedOutInput) (*sns.ListPhoneNumbersOptedOutOutput, error) {
	ret := m.ctrl.Call(m, "ListPhoneNumbersOptedOut", arg0)
	ret0, _ := ret[0].(*sns.ListPhoneNumbersOptedOutOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPhoneNumbersOptedOut indicates an expected call of ListPhoneNumbersOptedOut
func (mr *MockSNSAPIMockRecorder) ListPhoneNumbersOptedOut(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPhoneNumbersOptedOut", reflect.TypeOf((*MockSNSAPI)(nil).ListPhoneNumbersOptedOut), arg0)
}

// ListPhoneNumbersOptedOutWithContext mocks base method
func (m *MockSNSAPI) ListPhoneNumbersOptedOutWithContext(arg0 aws.Context, arg1 *sns.ListPhoneNumbersOptedOutInput, arg2 ...request.Option) (*sns.ListPhoneNumbersOptedOutOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPhoneNumbersOptedOutWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListPhoneNumbersOptedOutOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPhoneNumbersOptedOutRequest mocks base method
func (m *MockSNSAPI) ListPhoneNumbersOptedOutRequest(arg0 *sns.ListPhoneNumbersOptedOutInput) (*request.Request, *sns.ListPhoneNumbersOptedOutOutput) {
	ret := m.ctrl.Call(m, "ListPhoneNumbersOptedOutRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListPhoneNumbersOptedOutOutput)
	return ret0, ret1
}

// ListPhoneNumbersOptedOutRequest indicates an expected call of ListPhoneNumbersOptedOutRequest
func (mr *MockSNSAPIMockRecorder) ListPhoneNumbersOptedOutRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPhoneNumbersOptedOutRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListPhoneNumbersOptedOutRequest), arg0)
}

// ListPlatformApplications mocks base method
func (m *MockSNSAPI) ListPlatformApplications(arg0 *sns.ListPlatformApplicationsInput) (*sns.ListPlatformApplicationsOutput, error) {
	ret := m.ctrl.Call(m, "ListPlatformApplications", arg0)
	ret0, _ := ret[0].(*sns.ListPlatformApplicationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPlatformApplications indicates an expected call of ListPlatformApplications
func (mr *MockSNSAPIMockRecorder) ListPlatformApplications(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPlatformApplications", reflect.TypeOf((*MockSNSAPI)(nil).ListPlatformApplications), arg0)
}

// ListPlatformApplicationsWithContext mocks base method
func (m *MockSNSAPI) ListPlatformApplicationsWithContext(arg0 aws.Context, arg1 *sns.ListPlatformApplicationsInput, arg2 ...request.Option) (*sns.ListPlatformApplicationsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPlatformApplicationsWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListPlatformApplicationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPlatformApplicationsRequest mocks base method
func (m *MockSNSAPI) ListPlatformApplicationsRequest(arg0 *sns.ListPlatformApplicationsInput) (*request.Request, *sns.ListPlatformApplicationsOutput) {
	ret := m.ctrl.Call(m, "ListPlatformApplicationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListPlatformApplicationsOutput)
	return ret0, ret1
}

// ListPlatformApplicationsRequest indicates an expected call of ListPlatformApplicationsRequest
func (mr *MockSNSAPIMockRecorder) ListPlatformApplicationsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPlatformApplicationsRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListPlatformApplicationsRequest), arg0)
}

// ListPlatformApplicationsPages mocks base method
func (m *MockSNSAPI) ListPlatformApplicationsPages(arg0 *sns.ListPlatformApplicationsInput, arg1 func(*sns.ListPlatformApplicationsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListPlatformApplicationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPlatformApplicationsPages indicates an expected call of ListPlatformApplicationsPages
func (mr *MockSNSAPIMockRecorder) ListPlatformApplicationsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPlatformApplicationsPages", reflect.TypeOf((*MockSNSAPI)(nil).ListPlatformApplicationsPages), arg0, arg1)
}

// ListPlatformApplicationsPagesWithContext mocks base method
func (m *MockSNSAPI) ListPlatformApplicationsPagesWithContext(arg0 aws.Context, arg1 *sns.ListPlatformApplicationsInput, arg2 func(*sns.ListPlatformApplicationsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPlatformApplicationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListSubscriptions mocks base method
func (m *MockSNSAPI) ListSubscriptions(arg0 *sns.ListSubscriptionsInput) (*sns.ListSubscriptionsOutput, error) {
	ret := m.ctrl.Call(m, "ListSubscriptions", arg0)
	ret0, _ := ret[0].(*sns.ListSubscriptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSubscriptions indicates an expected call of ListSubscriptions
func (mr *MockSNSAPIMockRecorder) ListSubscriptions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptions", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptions), arg0)
}

// ListSubscriptionsWithContext mocks base method
func (m *MockSNSAPI) ListSubscriptionsWithContext(arg0 aws.Context, arg1 *sns.ListSubscriptionsInput, arg2 ...request.Option) (*sns.ListSubscriptionsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubscriptionsWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListSubscriptionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSubscriptionsRequest mocks base method
func (m *MockSNSAPI) ListSubscriptionsRequest(arg0 *sns.ListSubscriptionsInput) (*request.Request, *sns.ListSubscriptionsOutput) {
	ret := m.ctrl.Call(m, "ListSubscriptionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListSubscriptionsOutput)
	return ret0, ret1
}

// ListSubscriptionsRequest indicates an expected call of ListSubscriptionsRequest
func (mr *MockSNSAPIMockRecorder) ListSubscriptionsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptionsRequest), arg0)
}

// ListSubscriptionsPages mocks base method
func (m *MockSNSAPI) ListSubscriptionsPages(arg0 *sns.ListSubscriptionsInput, arg1 func(*sns.ListSubscriptionsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListSubscriptionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscriptionsPages indicates an expected call of ListSubscriptionsPages
func (mr *MockSNSAPIMockRecorder) ListSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsPages", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptionsPages), arg0, arg1)
}

// ListSubscriptionsPagesWithContext mocks base method
func (m *MockSNSAPI) ListSubscriptionsPagesWithContext(arg0 aws.Context, arg1 *sns.ListSubscriptionsInput, arg2 func(*sns.ListSubscriptionsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubscriptionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListSubscriptionsByTopic mocks base method
func (m *MockSNSAPI) ListSubscriptionsByTopic(arg0 *sns.ListSubscriptionsByTopicInput) (*sns.ListSubscriptionsByTopicOutput, error) {
	ret := m.ctrl.Call(m, "ListSubscriptionsByTopic", arg0)
	ret0, _ := ret[0].(*sns.ListSubscriptionsByTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSubscriptionsByTopic indicates an expected call of ListSubscriptionsByTopic
func (mr *MockSNSAPIMockRecorder) ListSubscriptionsByTopic(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsByTopic", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptionsByTopic), arg0)
}

// ListSubscriptionsByTopicWithContext mocks base method
func (m *MockSNSAPI) ListSubscriptionsByTopicWithContext(arg0 aws.Context, arg1 *sns.ListSubscriptionsByTopicInput, arg2 ...request.Option) (*sns.ListSubscriptionsByTopicOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubscriptionsByTopicWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListSubscriptionsByTopicOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSubscriptionsByTopicRequest mocks base method
func (m *MockSNSAPI) ListSubscriptionsByTopicRequest(arg0 *sns.ListSubscriptionsByTopicInput) (*request.Request, *sns.ListSubscriptionsByTopicOutput) {
	ret := m.ctrl.Call(m, "ListSubscriptionsByTopicRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListSubscriptionsByTopicOutput)
	return ret0, ret1
}

// ListSubscriptionsByTopicRequest indicates an expected call of ListSubscriptionsByTopicRequest
func (mr *MockSNSAPIMockRecorder) ListSubscriptionsByTopicRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsByTopicRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptionsByTopicRequest), arg0)
}

// ListSubscriptionsByTopicPages mocks base method
func (m *MockSNSAPI) ListSubscriptionsByTopicPages(arg0 *sns.ListSubscriptionsByTopicInput, arg1 func(*sns.ListSubscriptionsByTopicOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListSubscriptionsByTopicPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscriptionsByTopicPages indicates an expected call of ListSubscriptionsByTopicPages
func (mr *MockSNSAPIMockRecorder) ListSubscriptionsByTopicPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsByTopicPages", reflect.TypeOf((*MockSNSAPI)(nil).ListSubscriptionsByTopicPages), arg0, arg1)
}

// ListSubscriptionsByTopicPagesWithContext mocks base method
func (m *MockSNSAPI) ListSubscriptionsByTopicPagesWithContext(arg0 aws.Context, arg1 *sns.ListSubscriptionsByTopicInput, arg2 func(*sns.ListSubscriptionsByTopicOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSubscriptionsByTopicPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTopics mocks base method
func (m *MockSNSAPI) ListTopics(arg0 *sns.ListTopicsInput) (*sns.ListTopicsOutput, error) {
	ret := m.ctrl.Call(m, "ListTopics", arg0)
	ret0, _ := ret[0].(*sns.ListTopicsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics
func (mr *MockSNSAPIMockRecorder) ListTopics(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockSNSAPI)(nil).ListTopics), arg0)
}

// ListTopicsWithContext mocks base method
func (m *MockSNSAPI) ListTopicsWithContext(arg0 aws.Context, arg1 *sns.ListTopicsInput, arg2 ...request.Option) (*sns.ListTopicsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicsWithContext", varargs...)
	ret0, _ := ret[0].(*sns.ListTopicsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTopicsRequest mocks base method
func (m *MockSNSAPI) ListTopicsRequest(arg0 *sns.ListTopicsInput) (*request.Request, *sns.ListTopicsOutput) {
	ret := m.ctrl.Call(m, "ListTopicsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListTopicsOutput)
	return ret0, ret1
}

// ListTopicsRequest indicates an expected call of ListTopicsRequest
func (mr *MockSNSAPIMockRecorder) ListTopicsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopicsRequest", reflect.TypeOf((*MockSNSAPI)(nil).ListTopicsRequest), arg0)
}

// ListTopicsPages mocks base method
func (m *MockSNSAPI) ListTopicsPages(arg0 *sns.ListTopicsInput, arg1 func(*sns.ListTopicsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "ListTopicsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTopicsPages indicates an expected call of ListTopicsPages
func (mr *MockSNSAPIMockRecorder) ListTopicsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopicsPages", reflect.TypeOf((*MockSNSAPI)(nil).ListTopicsPages), arg0, arg1)
}

// ListTopicsPagesWithContext mocks base method
func (m *MockSNSAPI) ListTopicsPagesWithContext(arg0 aws.Context, arg1 *sns.ListTopicsInput, arg2 func(*sns.ListTopicsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopicsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// OptInPhoneNumber mocks base method
func (m *MockSNSAPI) OptInPhoneNumber(arg0 *sns.OptInPhoneNumberInput) (*sns.OptInPhoneNumberOutput, error) {
	ret := m.ctrl.Call(m, "OptInPhoneNumber", arg0)
	ret0, _ := ret[0].(*sns.OptInPhoneNumberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OptInPhoneNumber indicates an expected call of OptInPhoneNumber
func (mr *MockSNSAPIMockRecorder) OptInPhoneNumber(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OptInPhoneNumber", reflect.TypeOf((*MockSNSAPI)(nil).OptInPhoneNumber), arg0)
}

// OptInPhoneNumberWithContext mocks base method
func (m *MockSNSAPI) OptInPhoneNumberWithContext(arg0 aws.Context, arg1 *sns.OptInPhoneNumberInput, arg2 ...request.Option) (*sns.OptInPhoneNumberOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OptInPhoneNumberWithContext", varargs...)
	ret0, _ := ret[0].(*sns.OptInPhoneNumberOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OptInPhoneNumberRequest mocks base method
func (m *MockSNSAPI) OptInPhoneNumberRequest(arg0 *sns.OptInPhoneNumberInput) (*request.Request, *sns.OptInPhoneNumberOutput) {
	ret := m.ctrl.Call(m, "OptInPhoneNumberRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.OptInPhoneNumberOutput)
	return ret0, ret1
}

// OptInPhoneNumberRequest indicates an expected call of OptInPhoneNumberRequest
func (mr *MockSNSAPIMockRecorder) OptInPhoneNumberRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OptInPhoneNumberRequest", reflect.TypeOf((*MockSNSAPI)(nil).OptInPhoneNumberRequest), arg0)
}

// Publish mocks base method
func (m *MockSNSAPI) Publish(arg0 *sns.PublishInput) (*sns.PublishOutput, error) {
	ret := m.ctrl.Call(m, "Publish", arg0)
	ret0, _ := ret[0].(*sns.PublishOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Publish indicates an expected call of Publish
func (mr *MockSNSAPIMockRecorder) Publish(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockSNSAPI)(nil).Publish), arg0)
}

// PublishWithContext mocks base method
func (m *MockSNSAPI) PublishWithContext(arg0 aws.Context, arg1 *sns.PublishInput, arg2 ...request.Option) (*sns.PublishOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PublishWithContext", varargs...)
	ret0, _ := ret[0].(*sns.PublishOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PublishRequest mocks base method
func (m *MockSNSAPI) PublishRequest(arg0 *sns.PublishInput) (*request.Request, *sns.PublishOutput) {
	ret := m.ctrl.Call(m, "PublishRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.PublishOutput)
	return ret0, ret1
}

// PublishRequest indicates an expected call of PublishRequest
func (mr *MockSNSAPIMockRecorder) PublishRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishRequest", reflect.TypeOf((*MockSNSAPI)(nil).PublishRequest), arg0)
}

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

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

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

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

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

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

// SetEndpointAttributes mocks base method
func (m *MockSNSAPI) SetEndpointAttributes(arg0 *sns.SetEndpointAttributesInput) (*sns.SetEndpointAttributesOutput, error) {
	ret := m.ctrl.Call(m, "SetEndpointAttributes", arg0)
	ret0, _ := ret[0].(*sns.SetEndpointAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetEndpointAttributes indicates an expected call of SetEndpointAttributes
func (mr *MockSNSAPIMockRecorder) SetEndpointAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndpointAttributes", reflect.TypeOf((*MockSNSAPI)(nil).SetEndpointAttributes), arg0)
}

// SetEndpointAttributesWithContext mocks base method
func (m *MockSNSAPI) SetEndpointAttributesWithContext(arg0 aws.Context, arg1 *sns.SetEndpointAttributesInput, arg2 ...request.Option) (*sns.SetEndpointAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetEndpointAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SetEndpointAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetEndpointAttributesRequest mocks base method
func (m *MockSNSAPI) SetEndpointAttributesRequest(arg0 *sns.SetEndpointAttributesInput) (*request.Request, *sns.SetEndpointAttributesOutput) {
	ret := m.ctrl.Call(m, "SetEndpointAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SetEndpointAttributesOutput)
	return ret0, ret1
}

// SetEndpointAttributesRequest indicates an expected call of SetEndpointAttributesRequest
func (mr *MockSNSAPIMockRecorder) SetEndpointAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndpointAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).SetEndpointAttributesRequest), arg0)
}

// SetPlatformApplicationAttributes mocks base method
func (m *MockSNSAPI) SetPlatformApplicationAttributes(arg0 *sns.SetPlatformApplicationAttributesInput) (*sns.SetPlatformApplicationAttributesOutput, error) {
	ret := m.ctrl.Call(m, "SetPlatformApplicationAttributes", arg0)
	ret0, _ := ret[0].(*sns.SetPlatformApplicationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetPlatformApplicationAttributes indicates an expected call of SetPlatformApplicationAttributes
func (mr *MockSNSAPIMockRecorder) SetPlatformApplicationAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPlatformApplicationAttributes", reflect.TypeOf((*MockSNSAPI)(nil).SetPlatformApplicationAttributes), arg0)
}

// SetPlatformApplicationAttributesWithContext mocks base method
func (m *MockSNSAPI) SetPlatformApplicationAttributesWithContext(arg0 aws.Context, arg1 *sns.SetPlatformApplicationAttributesInput, arg2 ...request.Option) (*sns.SetPlatformApplicationAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetPlatformApplicationAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SetPlatformApplicationAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetPlatformApplicationAttributesRequest mocks base method
func (m *MockSNSAPI) SetPlatformApplicationAttributesRequest(arg0 *sns.SetPlatformApplicationAttributesInput) (*request.Request, *sns.SetPlatformApplicationAttributesOutput) {
	ret := m.ctrl.Call(m, "SetPlatformApplicationAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SetPlatformApplicationAttributesOutput)
	return ret0, ret1
}

// SetPlatformApplicationAttributesRequest indicates an expected call of SetPlatformApplicationAttributesRequest
func (mr *MockSNSAPIMockRecorder) SetPlatformApplicationAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPlatformApplicationAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).SetPlatformApplicationAttributesRequest), arg0)
}

// SetSMSAttributes mocks base method
func (m *MockSNSAPI) SetSMSAttributes(arg0 *sns.SetSMSAttributesInput) (*sns.SetSMSAttributesOutput, error) {
	ret := m.ctrl.Call(m, "SetSMSAttributes", arg0)
	ret0, _ := ret[0].(*sns.SetSMSAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetSMSAttributes indicates an expected call of SetSMSAttributes
func (mr *MockSNSAPIMockRecorder) SetSMSAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMSAttributes", reflect.TypeOf((*MockSNSAPI)(nil).SetSMSAttributes), arg0)
}

// SetSMSAttributesWithContext mocks base method
func (m *MockSNSAPI) SetSMSAttributesWithContext(arg0 aws.Context, arg1 *sns.SetSMSAttributesInput, arg2 ...request.Option) (*sns.SetSMSAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetSMSAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SetSMSAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetSMSAttributesRequest mocks base method
func (m *MockSNSAPI) SetSMSAttributesRequest(arg0 *sns.SetSMSAttributesInput) (*request.Request, *sns.SetSMSAttributesOutput) {
	ret := m.ctrl.Call(m, "SetSMSAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SetSMSAttributesOutput)
	return ret0, ret1
}

// SetSMSAttributesRequest indicates an expected call of SetSMSAttributesRequest
func (mr *MockSNSAPIMockRecorder) SetSMSAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMSAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).SetSMSAttributesRequest), arg0)
}

// SetSubscriptionAttributes mocks base method
func (m *MockSNSAPI) SetSubscriptionAttributes(arg0 *sns.SetSubscriptionAttributesInput) (*sns.SetSubscriptionAttributesOutput, error) {
	ret := m.ctrl.Call(m, "SetSubscriptionAttributes", arg0)
	ret0, _ := ret[0].(*sns.SetSubscriptionAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetSubscriptionAttributes indicates an expected call of SetSubscriptionAttributes
func (mr *MockSNSAPIMockRecorder) SetSubscriptionAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubscriptionAttributes", reflect.TypeOf((*MockSNSAPI)(nil).SetSubscriptionAttributes), arg0)
}

// SetSubscriptionAttributesWithContext mocks base method
func (m *MockSNSAPI) SetSubscriptionAttributesWithContext(arg0 aws.Context, arg1 *sns.SetSubscriptionAttributesInput, arg2 ...request.Option) (*sns.SetSubscriptionAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetSubscriptionAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SetSubscriptionAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetSubscriptionAttributesRequest mocks base method
func (m *MockSNSAPI) SetSubscriptionAttributesRequest(arg0 *sns.SetSubscriptionAttributesInput) (*request.Request, *sns.SetSubscriptionAttributesOutput) {
	ret := m.ctrl.Call(m, "SetSubscriptionAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SetSubscriptionAttributesOutput)
	return ret0, ret1
}

// SetSubscriptionAttributesRequest indicates an expected call of SetSubscriptionAttributesRequest
func (mr *MockSNSAPIMockRecorder) SetSubscriptionAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubscriptionAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).SetSubscriptionAttributesRequest), arg0)
}

// SetTopicAttributes mocks base method
func (m *MockSNSAPI) SetTopicAttributes(arg0 *sns.SetTopicAttributesInput) (*sns.SetTopicAttributesOutput, error) {
	ret := m.ctrl.Call(m, "SetTopicAttributes", arg0)
	ret0, _ := ret[0].(*sns.SetTopicAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetTopicAttributes indicates an expected call of SetTopicAttributes
func (mr *MockSNSAPIMockRecorder) SetTopicAttributes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTopicAttributes", reflect.TypeOf((*MockSNSAPI)(nil).SetTopicAttributes), arg0)
}

// SetTopicAttributesWithContext mocks base method
func (m *MockSNSAPI) SetTopicAttributesWithContext(arg0 aws.Context, arg1 *sns.SetTopicAttributesInput, arg2 ...request.Option) (*sns.SetTopicAttributesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetTopicAttributesWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SetTopicAttributesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetTopicAttributesRequest mocks base method
func (m *MockSNSAPI) SetTopicAttributesRequest(arg0 *sns.SetTopicAttributesInput) (*request.Request, *sns.SetTopicAttributesOutput) {
	ret := m.ctrl.Call(m, "SetTopicAttributesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SetTopicAttributesOutput)
	return ret0, ret1
}

// SetTopicAttributesRequest indicates an expected call of SetTopicAttributesRequest
func (mr *MockSNSAPIMockRecorder) SetTopicAttributesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTopicAttributesRequest", reflect.TypeOf((*MockSNSAPI)(nil).SetTopicAttributesRequest), arg0)
}

// Subscribe mocks base method
func (m *MockSNSAPI) Subscribe(arg0 *sns.SubscribeInput) (*sns.SubscribeOutput, error) {
	ret := m.ctrl.Call(m, "Subscribe", arg0)
	ret0, _ := ret[0].(*sns.SubscribeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Subscribe indicates an expected call of Subscribe
func (mr *MockSNSAPIMockRecorder) Subscribe(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockSNSAPI)(nil).Subscribe), arg0)
}

// SubscribeWithContext mocks base method
func (m *MockSNSAPI) SubscribeWithContext(arg0 aws.Context, arg1 *sns.SubscribeInput, arg2 ...request.Option) (*sns.SubscribeOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SubscribeWithContext", varargs...)
	ret0, _ := ret[0].(*sns.SubscribeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SubscribeRequest mocks base method
func (m *MockSNSAPI) SubscribeRequest(arg0 *sns.SubscribeInput) (*request.Request, *sns.SubscribeOutput) {
	ret := m.ctrl.Call(m, "SubscribeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.SubscribeOutput)
	return ret0, ret1
}

// SubscribeRequest indicates an expected call of SubscribeRequest
func (mr *MockSNSAPIMockRecorder) SubscribeRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeRequest", reflect.TypeOf((*MockSNSAPI)(nil).SubscribeRequest), arg0)
}

// Unsubscribe mocks base method
func (m *MockSNSAPI) Unsubscribe(arg0 *sns.UnsubscribeInput) (*sns.UnsubscribeOutput, error) {
	ret := m.ctrl.Call(m, "Unsubscribe", arg0)
	ret0, _ := ret[0].(*sns.UnsubscribeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Unsubscribe indicates an expected call of Unsubscribe
func (mr *MockSNSAPIMockRecorder) Unsubscribe(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockSNSAPI)(nil).Unsubscribe), arg0)
}

// UnsubscribeWithContext mocks base method
func (m *MockSNSAPI) UnsubscribeWithContext(arg0 aws.Context, arg1 *sns.UnsubscribeInput, arg2 ...request.Option) (*sns.UnsubscribeOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnsubscribeWithContext", varargs...)
	ret0, _ := ret[0].(*sns.UnsubscribeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnsubscribeRequest mocks base method
func (m *MockSNSAPI) UnsubscribeRequest(arg0 *sns.UnsubscribeInput) (*request.Request, *sns.UnsubscribeOutput) {
	ret := m.ctrl.Call(m, "UnsubscribeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.UnsubscribeOutput)
	return ret0, ret1
}

// UnsubscribeRequest indicates an expected call of UnsubscribeRequest
func (mr *MockSNSAPIMockRecorder) UnsubscribeRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeRequest", reflect.TypeOf((*MockSNSAPI)(nil).UnsubscribeRequest), arg0)
}