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

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

import (
	context "context"
	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"
)

// MockSNSClient is a mock of SNSClient interface
type MockSNSClient struct {
	ctrl     *gomock.Controller
	recorder *MockSNSClientMockRecorder
}

// MockSNSClientMockRecorder is the mock recorder for MockSNSClient
type MockSNSClientMockRecorder struct {
	mock *MockSNSClient
}

// NewMockSNSClient creates a new mock instance
func NewMockSNSClient(ctrl *gomock.Controller) *MockSNSClient {
	mock := &MockSNSClient{ctrl: ctrl}
	mock.recorder = &MockSNSClientMockRecorder{mock}
	return mock
}

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

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

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

// AddPermissionWithContext mocks base method
func (m *MockSNSClient) AddPermissionWithContext(arg0 context.Context, arg1 *sns.AddPermissionInput, arg2 ...request.Option) (*sns.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].(*sns.AddPermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddPermissionWithContext indicates an expected call of AddPermissionWithContext
func (mr *MockSNSClientMockRecorder) 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((*MockSNSClient)(nil).AddPermissionWithContext), varargs...)
}

// CheckIfPhoneNumberIsOptedOut mocks base method
func (m *MockSNSClient) CheckIfPhoneNumberIsOptedOut(arg0 *sns.CheckIfPhoneNumberIsOptedOutInput) (*sns.CheckIfPhoneNumberIsOptedOutOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CheckIfPhoneNumberIsOptedOut(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckIfPhoneNumberIsOptedOut", reflect.TypeOf((*MockSNSClient)(nil).CheckIfPhoneNumberIsOptedOut), arg0)
}

// CheckIfPhoneNumberIsOptedOutRequest mocks base method
func (m *MockSNSClient) CheckIfPhoneNumberIsOptedOutRequest(arg0 *sns.CheckIfPhoneNumberIsOptedOutInput) (*request.Request, *sns.CheckIfPhoneNumberIsOptedOutOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CheckIfPhoneNumberIsOptedOutRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckIfPhoneNumberIsOptedOutRequest", reflect.TypeOf((*MockSNSClient)(nil).CheckIfPhoneNumberIsOptedOutRequest), arg0)
}

// CheckIfPhoneNumberIsOptedOutWithContext mocks base method
func (m *MockSNSClient) CheckIfPhoneNumberIsOptedOutWithContext(arg0 context.Context, arg1 *sns.CheckIfPhoneNumberIsOptedOutInput, arg2 ...request.Option) (*sns.CheckIfPhoneNumberIsOptedOutOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CheckIfPhoneNumberIsOptedOutWithContext(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, "CheckIfPhoneNumberIsOptedOutWithContext", reflect.TypeOf((*MockSNSClient)(nil).CheckIfPhoneNumberIsOptedOutWithContext), varargs...)
}

// ConfirmSubscription mocks base method
func (m *MockSNSClient) ConfirmSubscription(arg0 *sns.ConfirmSubscriptionInput) (*sns.ConfirmSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ConfirmSubscription(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSubscription", reflect.TypeOf((*MockSNSClient)(nil).ConfirmSubscription), arg0)
}

// ConfirmSubscriptionRequest mocks base method
func (m *MockSNSClient) ConfirmSubscriptionRequest(arg0 *sns.ConfirmSubscriptionInput) (*request.Request, *sns.ConfirmSubscriptionOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ConfirmSubscriptionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSubscriptionRequest", reflect.TypeOf((*MockSNSClient)(nil).ConfirmSubscriptionRequest), arg0)
}

// ConfirmSubscriptionWithContext mocks base method
func (m *MockSNSClient) ConfirmSubscriptionWithContext(arg0 context.Context, arg1 *sns.ConfirmSubscriptionInput, arg2 ...request.Option) (*sns.ConfirmSubscriptionOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ConfirmSubscriptionWithContext(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, "ConfirmSubscriptionWithContext", reflect.TypeOf((*MockSNSClient)(nil).ConfirmSubscriptionWithContext), varargs...)
}

// CreatePlatformApplication mocks base method
func (m *MockSNSClient) CreatePlatformApplication(arg0 *sns.CreatePlatformApplicationInput) (*sns.CreatePlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformApplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformApplication", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformApplication), arg0)
}

// CreatePlatformApplicationRequest mocks base method
func (m *MockSNSClient) CreatePlatformApplicationRequest(arg0 *sns.CreatePlatformApplicationInput) (*request.Request, *sns.CreatePlatformApplicationOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformApplicationRequest", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformApplicationRequest), arg0)
}

// CreatePlatformApplicationWithContext mocks base method
func (m *MockSNSClient) CreatePlatformApplicationWithContext(arg0 context.Context, arg1 *sns.CreatePlatformApplicationInput, arg2 ...request.Option) (*sns.CreatePlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformApplicationWithContext(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, "CreatePlatformApplicationWithContext", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformApplicationWithContext), varargs...)
}

// CreatePlatformEndpoint mocks base method
func (m *MockSNSClient) CreatePlatformEndpoint(arg0 *sns.CreatePlatformEndpointInput) (*sns.CreatePlatformEndpointOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformEndpoint", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformEndpoint), arg0)
}

// CreatePlatformEndpointRequest mocks base method
func (m *MockSNSClient) CreatePlatformEndpointRequest(arg0 *sns.CreatePlatformEndpointInput) (*request.Request, *sns.CreatePlatformEndpointOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlatformEndpointRequest", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformEndpointRequest), arg0)
}

// CreatePlatformEndpointWithContext mocks base method
func (m *MockSNSClient) CreatePlatformEndpointWithContext(arg0 context.Context, arg1 *sns.CreatePlatformEndpointInput, arg2 ...request.Option) (*sns.CreatePlatformEndpointOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreatePlatformEndpointWithContext(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, "CreatePlatformEndpointWithContext", reflect.TypeOf((*MockSNSClient)(nil).CreatePlatformEndpointWithContext), varargs...)
}

// CreateTopic mocks base method
func (m *MockSNSClient) CreateTopic(arg0 *sns.CreateTopicInput) (*sns.CreateTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreateTopic(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopic", reflect.TypeOf((*MockSNSClient)(nil).CreateTopic), arg0)
}

// CreateTopicRequest mocks base method
func (m *MockSNSClient) CreateTopicRequest(arg0 *sns.CreateTopicInput) (*request.Request, *sns.CreateTopicOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreateTopicRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopicRequest", reflect.TypeOf((*MockSNSClient)(nil).CreateTopicRequest), arg0)
}

// CreateTopicWithContext mocks base method
func (m *MockSNSClient) CreateTopicWithContext(arg0 context.Context, arg1 *sns.CreateTopicInput, arg2 ...request.Option) (*sns.CreateTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) CreateTopicWithContext(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, "CreateTopicWithContext", reflect.TypeOf((*MockSNSClient)(nil).CreateTopicWithContext), varargs...)
}

// DeleteEndpoint mocks base method
func (m *MockSNSClient) DeleteEndpoint(arg0 *sns.DeleteEndpointInput) (*sns.DeleteEndpointOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteEndpoint(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpoint", reflect.TypeOf((*MockSNSClient)(nil).DeleteEndpoint), arg0)
}

// DeleteEndpointRequest mocks base method
func (m *MockSNSClient) DeleteEndpointRequest(arg0 *sns.DeleteEndpointInput) (*request.Request, *sns.DeleteEndpointOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteEndpointRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEndpointRequest", reflect.TypeOf((*MockSNSClient)(nil).DeleteEndpointRequest), arg0)
}

// DeleteEndpointWithContext mocks base method
func (m *MockSNSClient) DeleteEndpointWithContext(arg0 context.Context, arg1 *sns.DeleteEndpointInput, arg2 ...request.Option) (*sns.DeleteEndpointOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteEndpointWithContext(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, "DeleteEndpointWithContext", reflect.TypeOf((*MockSNSClient)(nil).DeleteEndpointWithContext), varargs...)
}

// DeletePlatformApplication mocks base method
func (m *MockSNSClient) DeletePlatformApplication(arg0 *sns.DeletePlatformApplicationInput) (*sns.DeletePlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeletePlatformApplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlatformApplication", reflect.TypeOf((*MockSNSClient)(nil).DeletePlatformApplication), arg0)
}

// DeletePlatformApplicationRequest mocks base method
func (m *MockSNSClient) DeletePlatformApplicationRequest(arg0 *sns.DeletePlatformApplicationInput) (*request.Request, *sns.DeletePlatformApplicationOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeletePlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlatformApplicationRequest", reflect.TypeOf((*MockSNSClient)(nil).DeletePlatformApplicationRequest), arg0)
}

// DeletePlatformApplicationWithContext mocks base method
func (m *MockSNSClient) DeletePlatformApplicationWithContext(arg0 context.Context, arg1 *sns.DeletePlatformApplicationInput, arg2 ...request.Option) (*sns.DeletePlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeletePlatformApplicationWithContext(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, "DeletePlatformApplicationWithContext", reflect.TypeOf((*MockSNSClient)(nil).DeletePlatformApplicationWithContext), varargs...)
}

// DeleteTopic mocks base method
func (m *MockSNSClient) DeleteTopic(arg0 *sns.DeleteTopicInput) (*sns.DeleteTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteTopic(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopic", reflect.TypeOf((*MockSNSClient)(nil).DeleteTopic), arg0)
}

// DeleteTopicRequest mocks base method
func (m *MockSNSClient) DeleteTopicRequest(arg0 *sns.DeleteTopicInput) (*request.Request, *sns.DeleteTopicOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteTopicRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopicRequest", reflect.TypeOf((*MockSNSClient)(nil).DeleteTopicRequest), arg0)
}

// DeleteTopicWithContext mocks base method
func (m *MockSNSClient) DeleteTopicWithContext(arg0 context.Context, arg1 *sns.DeleteTopicInput, arg2 ...request.Option) (*sns.DeleteTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) DeleteTopicWithContext(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, "DeleteTopicWithContext", reflect.TypeOf((*MockSNSClient)(nil).DeleteTopicWithContext), varargs...)
}

// GetEndpointAttributes mocks base method
func (m *MockSNSClient) GetEndpointAttributes(arg0 *sns.GetEndpointAttributesInput) (*sns.GetEndpointAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetEndpointAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointAttributes", reflect.TypeOf((*MockSNSClient)(nil).GetEndpointAttributes), arg0)
}

// GetEndpointAttributesRequest mocks base method
func (m *MockSNSClient) GetEndpointAttributesRequest(arg0 *sns.GetEndpointAttributesInput) (*request.Request, *sns.GetEndpointAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetEndpointAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndpointAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).GetEndpointAttributesRequest), arg0)
}

// GetEndpointAttributesWithContext mocks base method
func (m *MockSNSClient) GetEndpointAttributesWithContext(arg0 context.Context, arg1 *sns.GetEndpointAttributesInput, arg2 ...request.Option) (*sns.GetEndpointAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetEndpointAttributesWithContext(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, "GetEndpointAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).GetEndpointAttributesWithContext), varargs...)
}

// GetPlatformApplicationAttributes mocks base method
func (m *MockSNSClient) GetPlatformApplicationAttributes(arg0 *sns.GetPlatformApplicationAttributesInput) (*sns.GetPlatformApplicationAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetPlatformApplicationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlatformApplicationAttributes", reflect.TypeOf((*MockSNSClient)(nil).GetPlatformApplicationAttributes), arg0)
}

// GetPlatformApplicationAttributesRequest mocks base method
func (m *MockSNSClient) GetPlatformApplicationAttributesRequest(arg0 *sns.GetPlatformApplicationAttributesInput) (*request.Request, *sns.GetPlatformApplicationAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetPlatformApplicationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlatformApplicationAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).GetPlatformApplicationAttributesRequest), arg0)
}

// GetPlatformApplicationAttributesWithContext mocks base method
func (m *MockSNSClient) GetPlatformApplicationAttributesWithContext(arg0 context.Context, arg1 *sns.GetPlatformApplicationAttributesInput, arg2 ...request.Option) (*sns.GetPlatformApplicationAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetPlatformApplicationAttributesWithContext(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, "GetPlatformApplicationAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).GetPlatformApplicationAttributesWithContext), varargs...)
}

// GetSMSAttributes mocks base method
func (m *MockSNSClient) GetSMSAttributes(arg0 *sns.GetSMSAttributesInput) (*sns.GetSMSAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSMSAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSMSAttributes", reflect.TypeOf((*MockSNSClient)(nil).GetSMSAttributes), arg0)
}

// GetSMSAttributesRequest mocks base method
func (m *MockSNSClient) GetSMSAttributesRequest(arg0 *sns.GetSMSAttributesInput) (*request.Request, *sns.GetSMSAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSMSAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSMSAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).GetSMSAttributesRequest), arg0)
}

// GetSMSAttributesWithContext mocks base method
func (m *MockSNSClient) GetSMSAttributesWithContext(arg0 context.Context, arg1 *sns.GetSMSAttributesInput, arg2 ...request.Option) (*sns.GetSMSAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSMSAttributesWithContext(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, "GetSMSAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).GetSMSAttributesWithContext), varargs...)
}

// GetSubscriptionAttributes mocks base method
func (m *MockSNSClient) GetSubscriptionAttributes(arg0 *sns.GetSubscriptionAttributesInput) (*sns.GetSubscriptionAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSubscriptionAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionAttributes", reflect.TypeOf((*MockSNSClient)(nil).GetSubscriptionAttributes), arg0)
}

// GetSubscriptionAttributesRequest mocks base method
func (m *MockSNSClient) GetSubscriptionAttributesRequest(arg0 *sns.GetSubscriptionAttributesInput) (*request.Request, *sns.GetSubscriptionAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSubscriptionAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).GetSubscriptionAttributesRequest), arg0)
}

// GetSubscriptionAttributesWithContext mocks base method
func (m *MockSNSClient) GetSubscriptionAttributesWithContext(arg0 context.Context, arg1 *sns.GetSubscriptionAttributesInput, arg2 ...request.Option) (*sns.GetSubscriptionAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetSubscriptionAttributesWithContext(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, "GetSubscriptionAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).GetSubscriptionAttributesWithContext), varargs...)
}

// GetTopicAttributes mocks base method
func (m *MockSNSClient) GetTopicAttributes(arg0 *sns.GetTopicAttributesInput) (*sns.GetTopicAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetTopicAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopicAttributes", reflect.TypeOf((*MockSNSClient)(nil).GetTopicAttributes), arg0)
}

// GetTopicAttributesRequest mocks base method
func (m *MockSNSClient) GetTopicAttributesRequest(arg0 *sns.GetTopicAttributesInput) (*request.Request, *sns.GetTopicAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetTopicAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopicAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).GetTopicAttributesRequest), arg0)
}

// GetTopicAttributesWithContext mocks base method
func (m *MockSNSClient) GetTopicAttributesWithContext(arg0 context.Context, arg1 *sns.GetTopicAttributesInput, arg2 ...request.Option) (*sns.GetTopicAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) GetTopicAttributesWithContext(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, "GetTopicAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).GetTopicAttributesWithContext), varargs...)
}

// ListEndpointsByPlatformApplication mocks base method
func (m *MockSNSClient) ListEndpointsByPlatformApplication(arg0 *sns.ListEndpointsByPlatformApplicationInput) (*sns.ListEndpointsByPlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListEndpointsByPlatformApplication(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsByPlatformApplication", reflect.TypeOf((*MockSNSClient)(nil).ListEndpointsByPlatformApplication), arg0)
}

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

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

// ListEndpointsByPlatformApplicationPagesWithContext mocks base method
func (m *MockSNSClient) ListEndpointsByPlatformApplicationPagesWithContext(arg0 context.Context, arg1 *sns.ListEndpointsByPlatformApplicationInput, arg2 func(*sns.ListEndpointsByPlatformApplicationOutput, 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, "ListEndpointsByPlatformApplicationPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEndpointsByPlatformApplicationPagesWithContext indicates an expected call of ListEndpointsByPlatformApplicationPagesWithContext
func (mr *MockSNSClientMockRecorder) ListEndpointsByPlatformApplicationPagesWithContext(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, "ListEndpointsByPlatformApplicationPagesWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListEndpointsByPlatformApplicationPagesWithContext), varargs...)
}

// ListEndpointsByPlatformApplicationRequest mocks base method
func (m *MockSNSClient) ListEndpointsByPlatformApplicationRequest(arg0 *sns.ListEndpointsByPlatformApplicationInput) (*request.Request, *sns.ListEndpointsByPlatformApplicationOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListEndpointsByPlatformApplicationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEndpointsByPlatformApplicationRequest", reflect.TypeOf((*MockSNSClient)(nil).ListEndpointsByPlatformApplicationRequest), arg0)
}

// ListEndpointsByPlatformApplicationWithContext mocks base method
func (m *MockSNSClient) ListEndpointsByPlatformApplicationWithContext(arg0 context.Context, arg1 *sns.ListEndpointsByPlatformApplicationInput, arg2 ...request.Option) (*sns.ListEndpointsByPlatformApplicationOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListEndpointsByPlatformApplicationWithContext(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, "ListEndpointsByPlatformApplicationWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListEndpointsByPlatformApplicationWithContext), varargs...)
}

// ListPhoneNumbersOptedOut mocks base method
func (m *MockSNSClient) ListPhoneNumbersOptedOut(arg0 *sns.ListPhoneNumbersOptedOutInput) (*sns.ListPhoneNumbersOptedOutOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPhoneNumbersOptedOut(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPhoneNumbersOptedOut", reflect.TypeOf((*MockSNSClient)(nil).ListPhoneNumbersOptedOut), arg0)
}

// ListPhoneNumbersOptedOutRequest mocks base method
func (m *MockSNSClient) ListPhoneNumbersOptedOutRequest(arg0 *sns.ListPhoneNumbersOptedOutInput) (*request.Request, *sns.ListPhoneNumbersOptedOutOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPhoneNumbersOptedOutRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPhoneNumbersOptedOutRequest", reflect.TypeOf((*MockSNSClient)(nil).ListPhoneNumbersOptedOutRequest), arg0)
}

// ListPhoneNumbersOptedOutWithContext mocks base method
func (m *MockSNSClient) ListPhoneNumbersOptedOutWithContext(arg0 context.Context, arg1 *sns.ListPhoneNumbersOptedOutInput, arg2 ...request.Option) (*sns.ListPhoneNumbersOptedOutOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPhoneNumbersOptedOutWithContext(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, "ListPhoneNumbersOptedOutWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListPhoneNumbersOptedOutWithContext), varargs...)
}

// ListPlatformApplications mocks base method
func (m *MockSNSClient) ListPlatformApplications(arg0 *sns.ListPlatformApplicationsInput) (*sns.ListPlatformApplicationsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPlatformApplications(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPlatformApplications", reflect.TypeOf((*MockSNSClient)(nil).ListPlatformApplications), arg0)
}

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

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

// ListPlatformApplicationsPagesWithContext mocks base method
func (m *MockSNSClient) ListPlatformApplicationsPagesWithContext(arg0 context.Context, arg1 *sns.ListPlatformApplicationsInput, arg2 func(*sns.ListPlatformApplicationsOutput, 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, "ListPlatformApplicationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPlatformApplicationsPagesWithContext indicates an expected call of ListPlatformApplicationsPagesWithContext
func (mr *MockSNSClientMockRecorder) ListPlatformApplicationsPagesWithContext(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, "ListPlatformApplicationsPagesWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListPlatformApplicationsPagesWithContext), varargs...)
}

// ListPlatformApplicationsRequest mocks base method
func (m *MockSNSClient) ListPlatformApplicationsRequest(arg0 *sns.ListPlatformApplicationsInput) (*request.Request, *sns.ListPlatformApplicationsOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPlatformApplicationsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPlatformApplicationsRequest", reflect.TypeOf((*MockSNSClient)(nil).ListPlatformApplicationsRequest), arg0)
}

// ListPlatformApplicationsWithContext mocks base method
func (m *MockSNSClient) ListPlatformApplicationsWithContext(arg0 context.Context, arg1 *sns.ListPlatformApplicationsInput, arg2 ...request.Option) (*sns.ListPlatformApplicationsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListPlatformApplicationsWithContext(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, "ListPlatformApplicationsWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListPlatformApplicationsWithContext), varargs...)
}

// ListSubscriptions mocks base method
func (m *MockSNSClient) ListSubscriptions(arg0 *sns.ListSubscriptionsInput) (*sns.ListSubscriptionsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptions", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptions), arg0)
}

// ListSubscriptionsByTopic mocks base method
func (m *MockSNSClient) ListSubscriptionsByTopic(arg0 *sns.ListSubscriptionsByTopicInput) (*sns.ListSubscriptionsByTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptionsByTopic(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsByTopic", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsByTopic), arg0)
}

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

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

// ListSubscriptionsByTopicPagesWithContext mocks base method
func (m *MockSNSClient) ListSubscriptionsByTopicPagesWithContext(arg0 context.Context, arg1 *sns.ListSubscriptionsByTopicInput, arg2 func(*sns.ListSubscriptionsByTopicOutput, 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, "ListSubscriptionsByTopicPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscriptionsByTopicPagesWithContext indicates an expected call of ListSubscriptionsByTopicPagesWithContext
func (mr *MockSNSClientMockRecorder) ListSubscriptionsByTopicPagesWithContext(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, "ListSubscriptionsByTopicPagesWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsByTopicPagesWithContext), varargs...)
}

// ListSubscriptionsByTopicRequest mocks base method
func (m *MockSNSClient) ListSubscriptionsByTopicRequest(arg0 *sns.ListSubscriptionsByTopicInput) (*request.Request, *sns.ListSubscriptionsByTopicOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptionsByTopicRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsByTopicRequest", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsByTopicRequest), arg0)
}

// ListSubscriptionsByTopicWithContext mocks base method
func (m *MockSNSClient) ListSubscriptionsByTopicWithContext(arg0 context.Context, arg1 *sns.ListSubscriptionsByTopicInput, arg2 ...request.Option) (*sns.ListSubscriptionsByTopicOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptionsByTopicWithContext(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, "ListSubscriptionsByTopicWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsByTopicWithContext), varargs...)
}

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

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

// ListSubscriptionsPagesWithContext mocks base method
func (m *MockSNSClient) ListSubscriptionsPagesWithContext(arg0 context.Context, arg1 *sns.ListSubscriptionsInput, arg2 func(*sns.ListSubscriptionsOutput, 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, "ListSubscriptionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSubscriptionsPagesWithContext indicates an expected call of ListSubscriptionsPagesWithContext
func (mr *MockSNSClientMockRecorder) ListSubscriptionsPagesWithContext(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, "ListSubscriptionsPagesWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsPagesWithContext), varargs...)
}

// ListSubscriptionsRequest mocks base method
func (m *MockSNSClient) ListSubscriptionsRequest(arg0 *sns.ListSubscriptionsInput) (*request.Request, *sns.ListSubscriptionsOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptionsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubscriptionsRequest", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsRequest), arg0)
}

// ListSubscriptionsWithContext mocks base method
func (m *MockSNSClient) ListSubscriptionsWithContext(arg0 context.Context, arg1 *sns.ListSubscriptionsInput, arg2 ...request.Option) (*sns.ListSubscriptionsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListSubscriptionsWithContext(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, "ListSubscriptionsWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListSubscriptionsWithContext), varargs...)
}

// ListTagsForResource mocks base method
func (m *MockSNSClient) ListTagsForResource(arg0 *sns.ListTagsForResourceInput) (*sns.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*sns.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourceRequest mocks base method
func (m *MockSNSClient) ListTagsForResourceRequest(arg0 *sns.ListTagsForResourceInput) (*request.Request, *sns.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.ListTagsForResourceOutput)
	return ret0, ret1
}

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

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

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext
func (mr *MockSNSClientMockRecorder) ListTagsForResourceWithContext(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, "ListTagsForResourceWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListTagsForResourceWithContext), varargs...)
}

// ListTopics mocks base method
func (m *MockSNSClient) ListTopics(arg0 *sns.ListTopicsInput) (*sns.ListTopicsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListTopics(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockSNSClient)(nil).ListTopics), arg0)
}

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

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

// ListTopicsPagesWithContext mocks base method
func (m *MockSNSClient) ListTopicsPagesWithContext(arg0 context.Context, arg1 *sns.ListTopicsInput, arg2 func(*sns.ListTopicsOutput, 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, "ListTopicsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTopicsPagesWithContext indicates an expected call of ListTopicsPagesWithContext
func (mr *MockSNSClientMockRecorder) ListTopicsPagesWithContext(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, "ListTopicsPagesWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListTopicsPagesWithContext), varargs...)
}

// ListTopicsRequest mocks base method
func (m *MockSNSClient) ListTopicsRequest(arg0 *sns.ListTopicsInput) (*request.Request, *sns.ListTopicsOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListTopicsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopicsRequest", reflect.TypeOf((*MockSNSClient)(nil).ListTopicsRequest), arg0)
}

// ListTopicsWithContext mocks base method
func (m *MockSNSClient) ListTopicsWithContext(arg0 context.Context, arg1 *sns.ListTopicsInput, arg2 ...request.Option) (*sns.ListTopicsOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) ListTopicsWithContext(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, "ListTopicsWithContext", reflect.TypeOf((*MockSNSClient)(nil).ListTopicsWithContext), varargs...)
}

// OptInPhoneNumber mocks base method
func (m *MockSNSClient) OptInPhoneNumber(arg0 *sns.OptInPhoneNumberInput) (*sns.OptInPhoneNumberOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) OptInPhoneNumber(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OptInPhoneNumber", reflect.TypeOf((*MockSNSClient)(nil).OptInPhoneNumber), arg0)
}

// OptInPhoneNumberRequest mocks base method
func (m *MockSNSClient) OptInPhoneNumberRequest(arg0 *sns.OptInPhoneNumberInput) (*request.Request, *sns.OptInPhoneNumberOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) OptInPhoneNumberRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OptInPhoneNumberRequest", reflect.TypeOf((*MockSNSClient)(nil).OptInPhoneNumberRequest), arg0)
}

// OptInPhoneNumberWithContext mocks base method
func (m *MockSNSClient) OptInPhoneNumberWithContext(arg0 context.Context, arg1 *sns.OptInPhoneNumberInput, arg2 ...request.Option) (*sns.OptInPhoneNumberOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) OptInPhoneNumberWithContext(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, "OptInPhoneNumberWithContext", reflect.TypeOf((*MockSNSClient)(nil).OptInPhoneNumberWithContext), varargs...)
}

// Publish mocks base method
func (m *MockSNSClient) Publish(arg0 *sns.PublishInput) (*sns.PublishOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) Publish(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockSNSClient)(nil).Publish), arg0)
}

// PublishRequest mocks base method
func (m *MockSNSClient) PublishRequest(arg0 *sns.PublishInput) (*request.Request, *sns.PublishOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) PublishRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishRequest", reflect.TypeOf((*MockSNSClient)(nil).PublishRequest), arg0)
}

// PublishWithContext mocks base method
func (m *MockSNSClient) PublishWithContext(arg0 context.Context, arg1 *sns.PublishInput, arg2 ...request.Option) (*sns.PublishOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) PublishWithContext(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, "PublishWithContext", reflect.TypeOf((*MockSNSClient)(nil).PublishWithContext), varargs...)
}

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

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

// RemovePermissionWithContext mocks base method
func (m *MockSNSClient) RemovePermissionWithContext(arg0 context.Context, arg1 *sns.RemovePermissionInput, arg2 ...request.Option) (*sns.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].(*sns.RemovePermissionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemovePermissionWithContext indicates an expected call of RemovePermissionWithContext
func (mr *MockSNSClientMockRecorder) 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((*MockSNSClient)(nil).RemovePermissionWithContext), varargs...)
}

// SetEndpointAttributes mocks base method
func (m *MockSNSClient) SetEndpointAttributes(arg0 *sns.SetEndpointAttributesInput) (*sns.SetEndpointAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetEndpointAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndpointAttributes", reflect.TypeOf((*MockSNSClient)(nil).SetEndpointAttributes), arg0)
}

// SetEndpointAttributesRequest mocks base method
func (m *MockSNSClient) SetEndpointAttributesRequest(arg0 *sns.SetEndpointAttributesInput) (*request.Request, *sns.SetEndpointAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetEndpointAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndpointAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).SetEndpointAttributesRequest), arg0)
}

// SetEndpointAttributesWithContext mocks base method
func (m *MockSNSClient) SetEndpointAttributesWithContext(arg0 context.Context, arg1 *sns.SetEndpointAttributesInput, arg2 ...request.Option) (*sns.SetEndpointAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetEndpointAttributesWithContext(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, "SetEndpointAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).SetEndpointAttributesWithContext), varargs...)
}

// SetPlatformApplicationAttributes mocks base method
func (m *MockSNSClient) SetPlatformApplicationAttributes(arg0 *sns.SetPlatformApplicationAttributesInput) (*sns.SetPlatformApplicationAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetPlatformApplicationAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPlatformApplicationAttributes", reflect.TypeOf((*MockSNSClient)(nil).SetPlatformApplicationAttributes), arg0)
}

// SetPlatformApplicationAttributesRequest mocks base method
func (m *MockSNSClient) SetPlatformApplicationAttributesRequest(arg0 *sns.SetPlatformApplicationAttributesInput) (*request.Request, *sns.SetPlatformApplicationAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetPlatformApplicationAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPlatformApplicationAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).SetPlatformApplicationAttributesRequest), arg0)
}

// SetPlatformApplicationAttributesWithContext mocks base method
func (m *MockSNSClient) SetPlatformApplicationAttributesWithContext(arg0 context.Context, arg1 *sns.SetPlatformApplicationAttributesInput, arg2 ...request.Option) (*sns.SetPlatformApplicationAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetPlatformApplicationAttributesWithContext(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, "SetPlatformApplicationAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).SetPlatformApplicationAttributesWithContext), varargs...)
}

// SetSMSAttributes mocks base method
func (m *MockSNSClient) SetSMSAttributes(arg0 *sns.SetSMSAttributesInput) (*sns.SetSMSAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSMSAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMSAttributes", reflect.TypeOf((*MockSNSClient)(nil).SetSMSAttributes), arg0)
}

// SetSMSAttributesRequest mocks base method
func (m *MockSNSClient) SetSMSAttributesRequest(arg0 *sns.SetSMSAttributesInput) (*request.Request, *sns.SetSMSAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSMSAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMSAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).SetSMSAttributesRequest), arg0)
}

// SetSMSAttributesWithContext mocks base method
func (m *MockSNSClient) SetSMSAttributesWithContext(arg0 context.Context, arg1 *sns.SetSMSAttributesInput, arg2 ...request.Option) (*sns.SetSMSAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSMSAttributesWithContext(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, "SetSMSAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).SetSMSAttributesWithContext), varargs...)
}

// SetSubscriptionAttributes mocks base method
func (m *MockSNSClient) SetSubscriptionAttributes(arg0 *sns.SetSubscriptionAttributesInput) (*sns.SetSubscriptionAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSubscriptionAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubscriptionAttributes", reflect.TypeOf((*MockSNSClient)(nil).SetSubscriptionAttributes), arg0)
}

// SetSubscriptionAttributesRequest mocks base method
func (m *MockSNSClient) SetSubscriptionAttributesRequest(arg0 *sns.SetSubscriptionAttributesInput) (*request.Request, *sns.SetSubscriptionAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSubscriptionAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubscriptionAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).SetSubscriptionAttributesRequest), arg0)
}

// SetSubscriptionAttributesWithContext mocks base method
func (m *MockSNSClient) SetSubscriptionAttributesWithContext(arg0 context.Context, arg1 *sns.SetSubscriptionAttributesInput, arg2 ...request.Option) (*sns.SetSubscriptionAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetSubscriptionAttributesWithContext(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, "SetSubscriptionAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).SetSubscriptionAttributesWithContext), varargs...)
}

// SetTopicAttributes mocks base method
func (m *MockSNSClient) SetTopicAttributes(arg0 *sns.SetTopicAttributesInput) (*sns.SetTopicAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetTopicAttributes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTopicAttributes", reflect.TypeOf((*MockSNSClient)(nil).SetTopicAttributes), arg0)
}

// SetTopicAttributesRequest mocks base method
func (m *MockSNSClient) SetTopicAttributesRequest(arg0 *sns.SetTopicAttributesInput) (*request.Request, *sns.SetTopicAttributesOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetTopicAttributesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTopicAttributesRequest", reflect.TypeOf((*MockSNSClient)(nil).SetTopicAttributesRequest), arg0)
}

// SetTopicAttributesWithContext mocks base method
func (m *MockSNSClient) SetTopicAttributesWithContext(arg0 context.Context, arg1 *sns.SetTopicAttributesInput, arg2 ...request.Option) (*sns.SetTopicAttributesOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SetTopicAttributesWithContext(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, "SetTopicAttributesWithContext", reflect.TypeOf((*MockSNSClient)(nil).SetTopicAttributesWithContext), varargs...)
}

// Subscribe mocks base method
func (m *MockSNSClient) Subscribe(arg0 *sns.SubscribeInput) (*sns.SubscribeOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) Subscribe(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockSNSClient)(nil).Subscribe), arg0)
}

// SubscribeRequest mocks base method
func (m *MockSNSClient) SubscribeRequest(arg0 *sns.SubscribeInput) (*request.Request, *sns.SubscribeOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SubscribeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeRequest", reflect.TypeOf((*MockSNSClient)(nil).SubscribeRequest), arg0)
}

// SubscribeWithContext mocks base method
func (m *MockSNSClient) SubscribeWithContext(arg0 context.Context, arg1 *sns.SubscribeInput, arg2 ...request.Option) (*sns.SubscribeOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) SubscribeWithContext(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, "SubscribeWithContext", reflect.TypeOf((*MockSNSClient)(nil).SubscribeWithContext), varargs...)
}

// TagResource mocks base method
func (m *MockSNSClient) TagResource(arg0 *sns.TagResourceInput) (*sns.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*sns.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResourceRequest mocks base method
func (m *MockSNSClient) TagResourceRequest(arg0 *sns.TagResourceInput) (*request.Request, *sns.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.TagResourceOutput)
	return ret0, ret1
}

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

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

// TagResourceWithContext indicates an expected call of TagResourceWithContext
func (mr *MockSNSClientMockRecorder) TagResourceWithContext(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, "TagResourceWithContext", reflect.TypeOf((*MockSNSClient)(nil).TagResourceWithContext), varargs...)
}

// Unsubscribe mocks base method
func (m *MockSNSClient) Unsubscribe(arg0 *sns.UnsubscribeInput) (*sns.UnsubscribeOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) Unsubscribe(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockSNSClient)(nil).Unsubscribe), arg0)
}

// UnsubscribeRequest mocks base method
func (m *MockSNSClient) UnsubscribeRequest(arg0 *sns.UnsubscribeInput) (*request.Request, *sns.UnsubscribeOutput) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) UnsubscribeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeRequest", reflect.TypeOf((*MockSNSClient)(nil).UnsubscribeRequest), arg0)
}

// UnsubscribeWithContext mocks base method
func (m *MockSNSClient) UnsubscribeWithContext(arg0 context.Context, arg1 *sns.UnsubscribeInput, arg2 ...request.Option) (*sns.UnsubscribeOutput, error) {
	m.ctrl.T.Helper()
	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 *MockSNSClientMockRecorder) UnsubscribeWithContext(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, "UnsubscribeWithContext", reflect.TypeOf((*MockSNSClient)(nil).UnsubscribeWithContext), varargs...)
}

// UntagResource mocks base method
func (m *MockSNSClient) UntagResource(arg0 *sns.UntagResourceInput) (*sns.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*sns.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResourceRequest mocks base method
func (m *MockSNSClient) UntagResourceRequest(arg0 *sns.UntagResourceInput) (*request.Request, *sns.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*sns.UntagResourceOutput)
	return ret0, ret1
}

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

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

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext
func (mr *MockSNSClientMockRecorder) UntagResourceWithContext(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, "UntagResourceWithContext", reflect.TypeOf((*MockSNSClient)(nil).UntagResourceWithContext), varargs...)
}
