// Code generated by mockery v0.0.0-dev. DO NOT EDIT.

// @generated

package tmi

import (
	context "context"
	time "time"

	mock "github.com/stretchr/testify/mock"

	twitchclient "code.justin.tv/foundation/twitchclient"
)

// MockClient is an autogenerated mock type for the Client type
type MockClient struct {
	mock.Mock
}

// AddChannelBannedWord provides a mock function with given fields: ctx, channelID, requesterUserID, msg, reqOpts
func (_m *MockClient) AddChannelBannedWord(ctx context.Context, channelID string, requesterUserID string, msg AddChannelBannedWordParams, reqOpts *twitchclient.ReqOpts) (*AddChannelBlockedTermResponse, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, msg, reqOpts)

	var r0 *AddChannelBlockedTermResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, AddChannelBannedWordParams, *twitchclient.ReqOpts) *AddChannelBlockedTermResponse); ok {
		r0 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*AddChannelBlockedTermResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, AddChannelBannedWordParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddChannelPermittedWord provides a mock function with given fields: ctx, channelID, requesterUserID, msg, reqOpts
func (_m *MockClient) AddChannelPermittedWord(ctx context.Context, channelID string, requesterUserID string, msg AddChannelPermittedWordParams, reqOpts *twitchclient.ReqOpts) (*AddChannelPermittedTermResponse, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, msg, reqOpts)

	var r0 *AddChannelPermittedTermResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, AddChannelPermittedWordParams, *twitchclient.ReqOpts) *AddChannelPermittedTermResponse); ok {
		r0 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*AddChannelPermittedTermResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, AddChannelPermittedWordParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ApproveAutoModRejected provides a mock function with given fields: ctx, msgID, requesterUserID, reqOpts
func (_m *MockClient) ApproveAutoModRejected(ctx context.Context, msgID string, requesterUserID string, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, msgID, requesterUserID, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, msgID, requesterUserID, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// BanUser provides a mock function with given fields: ctx, channelID, bannedUserID, modUserID, expiresIn, reason, reqOpts
func (_m *MockClient) BanUser(ctx context.Context, channelID string, bannedUserID string, modUserID string, expiresIn *string, reason *string, reqOpts *twitchclient.ReqOpts) (*BanChannelUserResponse, error) {
	ret := _m.Called(ctx, channelID, bannedUserID, modUserID, expiresIn, reason, reqOpts)

	var r0 *BanChannelUserResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *string, *string, *twitchclient.ReqOpts) *BanChannelUserResponse); ok {
		r0 = rf(ctx, channelID, bannedUserID, modUserID, expiresIn, reason, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*BanChannelUserResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, *string, *string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, bannedUserID, modUserID, expiresIn, reason, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BotProperties provides a mock function with given fields: ctx, userID, reqOpts
func (_m *MockClient) BotProperties(ctx context.Context, userID string, reqOpts *twitchclient.ReqOpts) (BotPropertiesResponse, error) {
	ret := _m.Called(ctx, userID, reqOpts)

	var r0 BotPropertiesResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, *twitchclient.ReqOpts) BotPropertiesResponse); ok {
		r0 = rf(ctx, userID, reqOpts)
	} else {
		r0 = ret.Get(0).(BotPropertiesResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, userID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChannelBannedWords provides a mock function with given fields: ctx, channelID, requesterUserID, reqOpts
func (_m *MockClient) ChannelBannedWords(ctx context.Context, channelID string, requesterUserID string, reqOpts *twitchclient.ReqOpts) (*ChannelBannedWordsMessage, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, reqOpts)

	var r0 *ChannelBannedWordsMessage
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) *ChannelBannedWordsMessage); ok {
		r0 = rf(ctx, channelID, requesterUserID, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ChannelBannedWordsMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChannelPermittedWords provides a mock function with given fields: ctx, channelID, requesterUserID, reqOpts
func (_m *MockClient) ChannelPermittedWords(ctx context.Context, channelID string, requesterUserID string, reqOpts *twitchclient.ReqOpts) (*ChannelPermittedWordsMessage, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, reqOpts)

	var r0 *ChannelPermittedWordsMessage
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) *ChannelPermittedWordsMessage); ok {
		r0 = rf(ctx, channelID, requesterUserID, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ChannelPermittedWordsMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ChatRestrictedReasons provides a mock function with given fields: ctx, params, reqOpts
func (_m *MockClient) ChatRestrictedReasons(ctx context.Context, params ChatRestrictedReasonsParams, reqOpts *twitchclient.ReqOpts) (ChatRestrictedReasonsResponse, error) {
	ret := _m.Called(ctx, params, reqOpts)

	var r0 ChatRestrictedReasonsResponse
	if rf, ok := ret.Get(0).(func(context.Context, ChatRestrictedReasonsParams, *twitchclient.ReqOpts) ChatRestrictedReasonsResponse); ok {
		r0 = rf(ctx, params, reqOpts)
	} else {
		r0 = ret.Get(0).(ChatRestrictedReasonsResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, ChatRestrictedReasonsParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, params, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteChannelBannedWord provides a mock function with given fields: ctx, channelID, requesterUserID, msg, reqOpts
func (_m *MockClient) DeleteChannelBannedWord(ctx context.Context, channelID string, requesterUserID string, msg DeleteChannelBannedWordParams, reqOpts *twitchclient.ReqOpts) (*DeleteChannelBlockedTermResponse, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, msg, reqOpts)

	var r0 *DeleteChannelBlockedTermResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, DeleteChannelBannedWordParams, *twitchclient.ReqOpts) *DeleteChannelBlockedTermResponse); ok {
		r0 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*DeleteChannelBlockedTermResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, DeleteChannelBannedWordParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteChannelPermittedWord provides a mock function with given fields: ctx, channelID, requesterUserID, msg, reqOpts
func (_m *MockClient) DeleteChannelPermittedWord(ctx context.Context, channelID string, requesterUserID string, msg DeleteChannelPermittedWordParams, reqOpts *twitchclient.ReqOpts) (*DeleteChannelPermittedTermResponse, error) {
	ret := _m.Called(ctx, channelID, requesterUserID, msg, reqOpts)

	var r0 *DeleteChannelPermittedTermResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, DeleteChannelPermittedWordParams, *twitchclient.ReqOpts) *DeleteChannelPermittedTermResponse); ok {
		r0 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*DeleteChannelPermittedTermResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, DeleteChannelPermittedWordParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, requesterUserID, msg, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteChatMessage provides a mock function with given fields: ctx, params, reqOpts
func (_m *MockClient) DeleteChatMessage(ctx context.Context, params DeleteChatMessageRequest, reqOpts *twitchclient.ReqOpts) (DeleteChatMessageResponse, error) {
	ret := _m.Called(ctx, params, reqOpts)

	var r0 DeleteChatMessageResponse
	if rf, ok := ret.Get(0).(func(context.Context, DeleteChatMessageRequest, *twitchclient.ReqOpts) DeleteChatMessageResponse); ok {
		r0 = rf(ctx, params, reqOpts)
	} else {
		r0 = ret.Get(0).(DeleteChatMessageResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, DeleteChatMessageRequest, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, params, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DenyAutoModRejected provides a mock function with given fields: ctx, msgID, requesterUserID, reqOpts
func (_m *MockClient) DenyAutoModRejected(ctx context.Context, msgID string, requesterUserID string, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, msgID, requesterUserID, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, msgID, requesterUserID, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// GetAutoModRejectedMessage provides a mock function with given fields: ctx, msgID, reqOpts
func (_m *MockClient) GetAutoModRejectedMessage(ctx context.Context, msgID string, reqOpts *twitchclient.ReqOpts) (AutoModRejectedMessage, bool, error) {
	ret := _m.Called(ctx, msgID, reqOpts)

	var r0 AutoModRejectedMessage
	if rf, ok := ret.Get(0).(func(context.Context, string, *twitchclient.ReqOpts) AutoModRejectedMessage); ok {
		r0 = rf(ctx, msgID, reqOpts)
	} else {
		r0 = ret.Get(0).(AutoModRejectedMessage)
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(context.Context, string, *twitchclient.ReqOpts) bool); ok {
		r1 = rf(ctx, msgID, reqOpts)
	} else {
		r1 = ret.Get(1).(bool)
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string, *twitchclient.ReqOpts) error); ok {
		r2 = rf(ctx, msgID, reqOpts)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetBanStatus provides a mock function with given fields: ctx, channelID, userID, statusRequesterUserID, reqOpts
func (_m *MockClient) GetBanStatus(ctx context.Context, channelID string, userID string, statusRequesterUserID *string, reqOpts *twitchclient.ReqOpts) (ChannelBannedUser, bool, error) {
	ret := _m.Called(ctx, channelID, userID, statusRequesterUserID, reqOpts)

	var r0 ChannelBannedUser
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *string, *twitchclient.ReqOpts) ChannelBannedUser); ok {
		r0 = rf(ctx, channelID, userID, statusRequesterUserID, reqOpts)
	} else {
		r0 = ret.Get(0).(ChannelBannedUser)
	}

	var r1 bool
	if rf, ok := ret.Get(1).(func(context.Context, string, string, *string, *twitchclient.ReqOpts) bool); ok {
		r1 = rf(ctx, channelID, userID, statusRequesterUserID, reqOpts)
	} else {
		r1 = ret.Get(1).(bool)
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string, string, *string, *twitchclient.ReqOpts) error); ok {
		r2 = rf(ctx, channelID, userID, statusRequesterUserID, reqOpts)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetBots provides a mock function with given fields: ctx, reqOpts
func (_m *MockClient) GetBots(ctx context.Context, reqOpts *twitchclient.ReqOpts) (GetBotsResponse, error) {
	ret := _m.Called(ctx, reqOpts)

	var r0 GetBotsResponse
	if rf, ok := ret.Get(0).(func(context.Context, *twitchclient.ReqOpts) GetBotsResponse); ok {
		r0 = rf(ctx, reqOpts)
	} else {
		r0 = ret.Get(0).(GetBotsResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetChannelBannedUsers provides a mock function with given fields: ctx, channelID, limit, offset, includeTimeouts, reqOpts
func (_m *MockClient) GetChannelBannedUsers(ctx context.Context, channelID string, limit int, offset int, includeTimeouts bool, reqOpts *twitchclient.ReqOpts) (ChannelBannedUsersResponse, error) {
	ret := _m.Called(ctx, channelID, limit, offset, includeTimeouts, reqOpts)

	var r0 ChannelBannedUsersResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, int, int, bool, *twitchclient.ReqOpts) ChannelBannedUsersResponse); ok {
		r0 = rf(ctx, channelID, limit, offset, includeTimeouts, reqOpts)
	} else {
		r0 = ret.Get(0).(ChannelBannedUsersResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, int, int, bool, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, limit, offset, includeTimeouts, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHostTargets provides a mock function with given fields: ctx, channelIDs, reqOpts
func (_m *MockClient) GetHostTargets(ctx context.Context, channelIDs []string, reqOpts *twitchclient.ReqOpts) (*HostTargetsResponse, error) {
	ret := _m.Called(ctx, channelIDs, reqOpts)

	var r0 *HostTargetsResponse
	if rf, ok := ret.Get(0).(func(context.Context, []string, *twitchclient.ReqOpts) *HostTargetsResponse); ok {
		r0 = rf(ctx, channelIDs, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*HostTargetsResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, []string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelIDs, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetHosters provides a mock function with given fields: ctx, channelID, reqOpts
func (_m *MockClient) GetHosters(ctx context.Context, channelID string, reqOpts *twitchclient.ReqOpts) (*HostersResponse, error) {
	ret := _m.Called(ctx, channelID, reqOpts)

	var r0 *HostersResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, *twitchclient.ReqOpts) *HostersResponse); ok {
		r0 = rf(ctx, channelID, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*HostersResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetInternalRoomProperties provides a mock function with given fields: ctx, channelID, reqOpts
func (_m *MockClient) GetInternalRoomProperties(ctx context.Context, channelID string, reqOpts *twitchclient.ReqOpts) (*InternalRoomPropertiesResponse, error) {
	ret := _m.Called(ctx, channelID, reqOpts)

	var r0 *InternalRoomPropertiesResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, *twitchclient.ReqOpts) *InternalRoomPropertiesResponse); ok {
		r0 = rf(ctx, channelID, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*InternalRoomPropertiesResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, channelID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetVerifiedBots provides a mock function with given fields: ctx, reqOpts
func (_m *MockClient) GetVerifiedBots(ctx context.Context, reqOpts *twitchclient.ReqOpts) (GetVerifiedBotsResponse, error) {
	ret := _m.Called(ctx, reqOpts)

	var r0 GetVerifiedBotsResponse
	if rf, ok := ret.Get(0).(func(context.Context, *twitchclient.ReqOpts) GetVerifiedBotsResponse); ok {
		r0 = rf(ctx, reqOpts)
	} else {
		r0 = ret.Get(0).(GetVerifiedBotsResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GlobalBannedWords provides a mock function with given fields: ctx, reqOpts
func (_m *MockClient) GlobalBannedWords(ctx context.Context, reqOpts *twitchclient.ReqOpts) (*GlobalBannedWordsMessage, error) {
	ret := _m.Called(ctx, reqOpts)

	var r0 *GlobalBannedWordsMessage
	if rf, ok := ret.Get(0).(func(context.Context, *twitchclient.ReqOpts) *GlobalBannedWordsMessage); ok {
		r0 = rf(ctx, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*GlobalBannedWordsMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// IsVerifiedBot provides a mock function with given fields: ctx, userID, reqOpts
func (_m *MockClient) IsVerifiedBot(ctx context.Context, userID string, reqOpts *twitchclient.ReqOpts) (bool, error) {
	ret := _m.Called(ctx, userID, reqOpts)

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context, string, *twitchclient.ReqOpts) bool); ok {
		r0 = rf(ctx, userID, reqOpts)
	} else {
		r0 = ret.Get(0).(bool)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, userID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LastMessageTime provides a mock function with given fields: ctx, userID, roomID, reqOpts
func (_m *MockClient) LastMessageTime(ctx context.Context, userID string, roomID string, reqOpts *twitchclient.ReqOpts) (*time.Time, error) {
	ret := _m.Called(ctx, userID, roomID, reqOpts)

	var r0 *time.Time
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) *time.Time); ok {
		r0 = rf(ctx, userID, roomID, reqOpts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*time.Time)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, userID, roomID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyUserProperties provides a mock function with given fields: ctx, userID, params, reqOpts
func (_m *MockClient) ModifyUserProperties(ctx context.Context, userID string, params ModifyUserPropertiesParams, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, userID, params, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ModifyUserPropertiesParams, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, userID, params, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SendExtensionMessage provides a mock function with given fields: ctx, message, reqOpts
func (_m *MockClient) SendExtensionMessage(ctx context.Context, message ExtensionMessage, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, message, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, ExtensionMessage, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, message, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SendMessage provides a mock function with given fields: ctx, params, reqOpts
func (_m *MockClient) SendMessage(ctx context.Context, params SendMessageParams, reqOpts *twitchclient.ReqOpts) (SendMessageResponse, error) {
	ret := _m.Called(ctx, params, reqOpts)

	var r0 SendMessageResponse
	if rf, ok := ret.Get(0).(func(context.Context, SendMessageParams, *twitchclient.ReqOpts) SendMessageResponse); ok {
		r0 = rf(ctx, params, reqOpts)
	} else {
		r0 = ret.Get(0).(SendMessageResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, SendMessageParams, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, params, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// SendUserNotice provides a mock function with given fields: ctx, params, reqOpts
func (_m *MockClient) SendUserNotice(ctx context.Context, params SendUserNoticeParams, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, params, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, SendUserNoticeParams, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, params, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// SendWhisper provides a mock function with given fields: ctx, params, reqOpts
func (_m *MockClient) SendWhisper(ctx context.Context, params SendWhisperParams, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, params, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, SendWhisperParams, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, params, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UnbanUser provides a mock function with given fields: ctx, channelID, userID, modID, reqOpts
func (_m *MockClient) UnbanUser(ctx context.Context, channelID string, userID string, modID string, reqOpts *twitchclient.ReqOpts) (string, *ChannelBannedUser, error) {
	ret := _m.Called(ctx, channelID, userID, modID, reqOpts)

	var r0 string
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *twitchclient.ReqOpts) string); ok {
		r0 = rf(ctx, channelID, userID, modID, reqOpts)
	} else {
		r0 = ret.Get(0).(string)
	}

	var r1 *ChannelBannedUser
	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, *twitchclient.ReqOpts) *ChannelBannedUser); ok {
		r1 = rf(ctx, channelID, userID, modID, reqOpts)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*ChannelBannedUser)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(context.Context, string, string, string, *twitchclient.ReqOpts) error); ok {
		r2 = rf(ctx, channelID, userID, modID, reqOpts)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// UpdateInternalRoomProperties provides a mock function with given fields: ctx, channelID, params, reqOpts
func (_m *MockClient) UpdateInternalRoomProperties(ctx context.Context, channelID string, params UpdateInternalRoomPropertiesRequest, reqOpts *twitchclient.ReqOpts) error {
	ret := _m.Called(ctx, channelID, params, reqOpts)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, UpdateInternalRoomPropertiesRequest, *twitchclient.ReqOpts) error); ok {
		r0 = rf(ctx, channelID, params, reqOpts)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UserFirstRoomChat provides a mock function with given fields: ctx, userID, roomID, reqOpts
func (_m *MockClient) UserFirstRoomChat(ctx context.Context, userID string, roomID string, reqOpts *twitchclient.ReqOpts) (UserFirstRoomChatResponse, error) {
	ret := _m.Called(ctx, userID, roomID, reqOpts)

	var r0 UserFirstRoomChatResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *twitchclient.ReqOpts) UserFirstRoomChatResponse); ok {
		r0 = rf(ctx, userID, roomID, reqOpts)
	} else {
		r0 = ret.Get(0).(UserFirstRoomChatResponse)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, string, string, *twitchclient.ReqOpts) error); ok {
		r1 = rf(ctx, userID, roomID, reqOpts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
