// Code generated by MockGen. DO NOT EDIT.
// Source: service.go
//
// Generated by this command:
//
//	mockgen -source=service.go -destination=mocks/mock.go
//

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

import (
	context "context"
	encoding "encoding"
	http "net/http"
	reflect "reflect"
	time "time"

	domain "git.urec56.ru/urec/chat_back_go/internal/domain"
	jwt "github.com/golang-jwt/jwt/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockUser is a mock of User interface.
type MockUser struct {
	ctrl     *gomock.Controller
	recorder *MockUserMockRecorder
}

// MockUserMockRecorder is the mock recorder for MockUser.
type MockUserMockRecorder struct {
	mock *MockUser
}

// NewMockUser creates a new mock instance.
func NewMockUser(ctrl *gomock.Controller) *MockUser {
	mock := &MockUser{ctrl: ctrl}
	mock.recorder = &MockUserMockRecorder{mock}
	return mock
}

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

// FindOne mocks base method.
func (m *MockUser) FindOne(username, email string) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", username, email)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockUserMockRecorder) FindOne(username, email any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockUser)(nil).FindOne), username, email)
}

// Get mocks base method.
func (m *MockUser) Get(userID int, isFast bool) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", userID, isFast)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockUserMockRecorder) Get(userID, isFast any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUser)(nil).Get), userID, isFast)
}

// GetAll mocks base method.
func (m *MockUser) GetAll(username string) ([]domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAll", username)
	ret0, _ := ret[0].([]domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAll indicates an expected call of GetAll.
func (mr *MockUserMockRecorder) GetAll(username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockUser)(nil).GetAll), username)
}

// GetVerificated mocks base method.
func (m *MockUser) GetVerificated(userID int) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerificated", userID)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVerificated indicates an expected call of GetVerificated.
func (mr *MockUserMockRecorder) GetVerificated(userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerificated", reflect.TypeOf((*MockUser)(nil).GetVerificated), userID)
}

// Register mocks base method.
func (m *MockUser) Register(userData domain.UserRegister) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Register", userData)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Register indicates an expected call of Register.
func (mr *MockUserMockRecorder) Register(userData any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockUser)(nil).Register), userData)
}

// MockAuth is a mock of Auth interface.
type MockAuth struct {
	ctrl     *gomock.Controller
	recorder *MockAuthMockRecorder
}

// MockAuthMockRecorder is the mock recorder for MockAuth.
type MockAuthMockRecorder struct {
	mock *MockAuth
}

// NewMockAuth creates a new mock instance.
func NewMockAuth(ctrl *gomock.Controller) *MockAuth {
	mock := &MockAuth{ctrl: ctrl}
	mock.recorder = &MockAuthMockRecorder{mock}
	return mock
}

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

// DecodeAuthToken mocks base method.
func (m *MockAuth) DecodeAuthToken(token string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeAuthToken", token)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecodeAuthToken indicates an expected call of DecodeAuthToken.
func (mr *MockAuthMockRecorder) DecodeAuthToken(token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthToken", reflect.TypeOf((*MockAuth)(nil).DecodeAuthToken), token)
}

// EncodeAuthToken mocks base method.
func (m *MockAuth) EncodeAuthToken(userID int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncodeAuthToken", userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EncodeAuthToken indicates an expected call of EncodeAuthToken.
func (mr *MockAuthMockRecorder) EncodeAuthToken(userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeAuthToken", reflect.TypeOf((*MockAuth)(nil).EncodeAuthToken), userID)
}

// ExtractAuthToken mocks base method.
func (m *MockAuth) ExtractAuthToken(r *http.Request) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractAuthToken", r)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExtractAuthToken indicates an expected call of ExtractAuthToken.
func (mr *MockAuthMockRecorder) ExtractAuthToken(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtractAuthToken", reflect.TypeOf((*MockAuth)(nil).ExtractAuthToken), r)
}

// HashPassword mocks base method.
func (m *MockAuth) HashPassword(p string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HashPassword", p)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HashPassword indicates an expected call of HashPassword.
func (mr *MockAuthMockRecorder) HashPassword(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashPassword", reflect.TypeOf((*MockAuth)(nil).HashPassword), p)
}

// VerifyHashedPassword mocks base method.
func (m *MockAuth) VerifyHashedPassword(p, hp string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHashedPassword", p, hp)
	ret0, _ := ret[0].(bool)
	return ret0
}

// VerifyHashedPassword indicates an expected call of VerifyHashedPassword.
func (mr *MockAuthMockRecorder) VerifyHashedPassword(p, hp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHashedPassword", reflect.TypeOf((*MockAuth)(nil).VerifyHashedPassword), p, hp)
}

// MockChat is a mock of Chat interface.
type MockChat struct {
	ctrl     *gomock.Controller
	recorder *MockChatMockRecorder
}

// MockChatMockRecorder is the mock recorder for MockChat.
type MockChatMockRecorder struct {
	mock *MockChat
}

// NewMockChat creates a new mock instance.
func NewMockChat(ctrl *gomock.Controller) *MockChat {
	mock := &MockChat{ctrl: ctrl}
	mock.recorder = &MockChatMockRecorder{mock}
	return mock
}

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

// MockMessages is a mock of Messages interface.
type MockMessages struct {
	ctrl     *gomock.Controller
	recorder *MockMessagesMockRecorder
}

// MockMessagesMockRecorder is the mock recorder for MockMessages.
type MockMessagesMockRecorder struct {
	mock *MockMessages
}

// NewMockMessages creates a new mock instance.
func NewMockMessages(ctrl *gomock.Controller) *MockMessages {
	mock := &MockMessages{ctrl: ctrl}
	mock.recorder = &MockMessagesMockRecorder{mock}
	return mock
}

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

// AddAvatarImageAndUsernameToMessage mocks base method.
func (m *MockMessages) AddAvatarImageAndUsernameToMessage(msgRaw domain.RawMessage) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAvatarImageAndUsernameToMessage", msgRaw)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddAvatarImageAndUsernameToMessage indicates an expected call of AddAvatarImageAndUsernameToMessage.
func (mr *MockMessagesMockRecorder) AddAvatarImageAndUsernameToMessage(msgRaw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAvatarImageAndUsernameToMessage", reflect.TypeOf((*MockMessages)(nil).AddAvatarImageAndUsernameToMessage), msgRaw)
}

// AddAvatarImageAndUsernameToMessages mocks base method.
func (m *MockMessages) AddAvatarImageAndUsernameToMessages(msgsRaw []domain.RawMessage) []domain.Message {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAvatarImageAndUsernameToMessages", msgsRaw)
	ret0, _ := ret[0].([]domain.Message)
	return ret0
}

// AddAvatarImageAndUsernameToMessages indicates an expected call of AddAvatarImageAndUsernameToMessages.
func (mr *MockMessagesMockRecorder) AddAvatarImageAndUsernameToMessages(msgsRaw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAvatarImageAndUsernameToMessages", reflect.TypeOf((*MockMessages)(nil).AddAvatarImageAndUsernameToMessages), msgsRaw)
}

// Delete mocks base method.
func (m *MockMessages) Delete(ID domain.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockMessagesMockRecorder) Delete(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockMessages)(nil).Delete), ID)
}

// Edit mocks base method.
func (m *MockMessages) Edit(ID domain.UUID, newMessage, newImageUrl string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Edit", ID, newMessage, newImageUrl)
	ret0, _ := ret[0].(error)
	return ret0
}

// Edit indicates an expected call of Edit.
func (mr *MockMessagesMockRecorder) Edit(ID, newMessage, newImageUrl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Edit", reflect.TypeOf((*MockMessages)(nil).Edit), ID, newMessage, newImageUrl)
}

// GetMessage mocks base method.
func (m *MockMessages) GetMessage(ID domain.UUID) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMessage", ID)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessage indicates an expected call of GetMessage.
func (mr *MockMessagesMockRecorder) GetMessage(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessage", reflect.TypeOf((*MockMessages)(nil).GetMessage), ID)
}

// GetPinned mocks base method.
func (m *MockMessages) GetPinned(chatID int) ([]domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPinned", chatID)
	ret0, _ := ret[0].([]domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPinned indicates an expected call of GetPinned.
func (mr *MockMessagesMockRecorder) GetPinned(chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPinned", reflect.TypeOf((*MockMessages)(nil).GetPinned), chatID)
}

// GetRaw mocks base method.
func (m *MockMessages) GetRaw(ID domain.UUID) (domain.RawMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRaw", ID)
	ret0, _ := ret[0].(domain.RawMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRaw indicates an expected call of GetRaw.
func (mr *MockMessagesMockRecorder) GetRaw(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRaw", reflect.TypeOf((*MockMessages)(nil).GetRaw), ID)
}

// GetSome mocks base method.
func (m *MockMessages) GetSome(chatID, offset, limit int) ([]domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSome", chatID, offset, limit)
	ret0, _ := ret[0].([]domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSome indicates an expected call of GetSome.
func (mr *MockMessagesMockRecorder) GetSome(chatID, offset, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSome", reflect.TypeOf((*MockMessages)(nil).GetSome), chatID, offset, limit)
}

// Pin mocks base method.
func (m *MockMessages) Pin(chatID, userID int, messageID domain.UUID) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pin", chatID, userID, messageID)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pin indicates an expected call of Pin.
func (mr *MockMessagesMockRecorder) Pin(chatID, userID, messageID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pin", reflect.TypeOf((*MockMessages)(nil).Pin), chatID, userID, messageID)
}

// SendMessage mocks base method.
func (m *MockMessages) SendMessage(userID, chatID int, message domain.SendMessage) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessage", userID, chatID, message)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockMessagesMockRecorder) SendMessage(userID, chatID, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockMessages)(nil).SendMessage), userID, chatID, message)
}

// Unpin mocks base method.
func (m *MockMessages) Unpin(chatID int, messageID domain.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unpin", chatID, messageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unpin indicates an expected call of Unpin.
func (mr *MockMessagesMockRecorder) Unpin(chatID, messageID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unpin", reflect.TypeOf((*MockMessages)(nil).Unpin), chatID, messageID)
}

// MockCache is a mock of Cache interface.
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
}

// MockCacheMockRecorder is the mock recorder for MockCache.
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance.
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockCache) Get(key string, v encoding.BinaryUnmarshaler, isFast bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key, v, isFast)
	ret0, _ := ret[0].(error)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockCacheMockRecorder) Get(key, v, isFast any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), key, v, isFast)
}

// GetCtx mocks base method.
func (m *MockCache) GetCtx(ctx context.Context, key string, v encoding.BinaryUnmarshaler, isFast bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCtx", ctx, key, v, isFast)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetCtx indicates an expected call of GetCtx.
func (mr *MockCacheMockRecorder) GetCtx(ctx, key, v, isFast any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCtx", reflect.TypeOf((*MockCache)(nil).GetCtx), ctx, key, v, isFast)
}

// Set mocks base method.
func (m *MockCache) Set(key string, v encoding.BinaryMarshaler, ex time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", key, v, ex)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockCacheMockRecorder) Set(key, v, ex any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), key, v, ex)
}

// SetCtx mocks base method.
func (m *MockCache) SetCtx(ctx context.Context, key string, v encoding.BinaryMarshaler, ex time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCtx", ctx, key, v, ex)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetCtx indicates an expected call of SetCtx.
func (mr *MockCacheMockRecorder) SetCtx(ctx, key, v, ex any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCtx", reflect.TypeOf((*MockCache)(nil).SetCtx), ctx, key, v, ex)
}

// MockParser is a mock of Parser interface.
type MockParser struct {
	ctrl     *gomock.Controller
	recorder *MockParserMockRecorder
}

// MockParserMockRecorder is the mock recorder for MockParser.
type MockParserMockRecorder struct {
	mock *MockParser
}

// NewMockParser creates a new mock instance.
func NewMockParser(ctrl *gomock.Controller) *MockParser {
	mock := &MockParser{ctrl: ctrl}
	mock.recorder = &MockParserMockRecorder{mock}
	return mock
}

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

// DecodeSegment mocks base method.
func (m *MockParser) DecodeSegment(seg string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeSegment", seg)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecodeSegment indicates an expected call of DecodeSegment.
func (mr *MockParserMockRecorder) DecodeSegment(seg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeSegment", reflect.TypeOf((*MockParser)(nil).DecodeSegment), seg)
}

// Parse mocks base method.
func (m *MockParser) Parse(tokenString string, keyFunc jwt.Keyfunc) (*jwt.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Parse", tokenString, keyFunc)
	ret0, _ := ret[0].(*jwt.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Parse indicates an expected call of Parse.
func (mr *MockParserMockRecorder) Parse(tokenString, keyFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Parse", reflect.TypeOf((*MockParser)(nil).Parse), tokenString, keyFunc)
}

// ParseUnverified mocks base method.
func (m *MockParser) ParseUnverified(tokenString string, claims jwt.Claims) (*jwt.Token, []string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseUnverified", tokenString, claims)
	ret0, _ := ret[0].(*jwt.Token)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ParseUnverified indicates an expected call of ParseUnverified.
func (mr *MockParserMockRecorder) ParseUnverified(tokenString, claims any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseUnverified", reflect.TypeOf((*MockParser)(nil).ParseUnverified), tokenString, claims)
}

// ParseWithClaims mocks base method.
func (m *MockParser) ParseWithClaims(tokenString string, claims jwt.Claims, keyFunc jwt.Keyfunc) (*jwt.Token, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParseWithClaims", tokenString, claims, keyFunc)
	ret0, _ := ret[0].(*jwt.Token)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ParseWithClaims indicates an expected call of ParseWithClaims.
func (mr *MockParserMockRecorder) ParseWithClaims(tokenString, claims, keyFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParseWithClaims", reflect.TypeOf((*MockParser)(nil).ParseWithClaims), tokenString, claims, keyFunc)
}

// MockClaims is a mock of Claims interface.
type MockClaims struct {
	ctrl     *gomock.Controller
	recorder *MockClaimsMockRecorder
}

// MockClaimsMockRecorder is the mock recorder for MockClaims.
type MockClaimsMockRecorder struct {
	mock *MockClaims
}

// NewMockClaims creates a new mock instance.
func NewMockClaims(ctrl *gomock.Controller) *MockClaims {
	mock := &MockClaims{ctrl: ctrl}
	mock.recorder = &MockClaimsMockRecorder{mock}
	return mock
}

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

// GetAudience mocks base method.
func (m *MockClaims) GetAudience() (jwt.ClaimStrings, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAudience")
	ret0, _ := ret[0].(jwt.ClaimStrings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAudience indicates an expected call of GetAudience.
func (mr *MockClaimsMockRecorder) GetAudience() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAudience", reflect.TypeOf((*MockClaims)(nil).GetAudience))
}

// GetExpirationTime mocks base method.
func (m *MockClaims) GetExpirationTime() (*jwt.NumericDate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpirationTime")
	ret0, _ := ret[0].(*jwt.NumericDate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExpirationTime indicates an expected call of GetExpirationTime.
func (mr *MockClaimsMockRecorder) GetExpirationTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExpirationTime", reflect.TypeOf((*MockClaims)(nil).GetExpirationTime))
}

// GetIssuedAt mocks base method.
func (m *MockClaims) GetIssuedAt() (*jwt.NumericDate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssuedAt")
	ret0, _ := ret[0].(*jwt.NumericDate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssuedAt indicates an expected call of GetIssuedAt.
func (mr *MockClaimsMockRecorder) GetIssuedAt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssuedAt", reflect.TypeOf((*MockClaims)(nil).GetIssuedAt))
}

// GetIssuer mocks base method.
func (m *MockClaims) GetIssuer() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIssuer")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIssuer indicates an expected call of GetIssuer.
func (mr *MockClaimsMockRecorder) GetIssuer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssuer", reflect.TypeOf((*MockClaims)(nil).GetIssuer))
}

// GetNotBefore mocks base method.
func (m *MockClaims) GetNotBefore() (*jwt.NumericDate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotBefore")
	ret0, _ := ret[0].(*jwt.NumericDate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotBefore indicates an expected call of GetNotBefore.
func (mr *MockClaimsMockRecorder) GetNotBefore() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotBefore", reflect.TypeOf((*MockClaims)(nil).GetNotBefore))
}

// GetSubject mocks base method.
func (m *MockClaims) GetSubject() (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubject")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubject indicates an expected call of GetSubject.
func (mr *MockClaimsMockRecorder) GetSubject() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubject", reflect.TypeOf((*MockClaims)(nil).GetSubject))
}

// MockServ is a mock of Serv interface.
type MockServ struct {
	ctrl     *gomock.Controller
	recorder *MockServMockRecorder
}

// MockServMockRecorder is the mock recorder for MockServ.
type MockServMockRecorder struct {
	mock *MockServ
}

// NewMockServ creates a new mock instance.
func NewMockServ(ctrl *gomock.Controller) *MockServ {
	mock := &MockServ{ctrl: ctrl}
	mock.recorder = &MockServMockRecorder{mock}
	return mock
}

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

// AddAvatarImageAndUsernameToMessage mocks base method.
func (m *MockServ) AddAvatarImageAndUsernameToMessage(msgRaw domain.RawMessage) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAvatarImageAndUsernameToMessage", msgRaw)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddAvatarImageAndUsernameToMessage indicates an expected call of AddAvatarImageAndUsernameToMessage.
func (mr *MockServMockRecorder) AddAvatarImageAndUsernameToMessage(msgRaw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAvatarImageAndUsernameToMessage", reflect.TypeOf((*MockServ)(nil).AddAvatarImageAndUsernameToMessage), msgRaw)
}

// AddAvatarImageAndUsernameToMessages mocks base method.
func (m *MockServ) AddAvatarImageAndUsernameToMessages(msgsRaw []domain.RawMessage) []domain.Message {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAvatarImageAndUsernameToMessages", msgsRaw)
	ret0, _ := ret[0].([]domain.Message)
	return ret0
}

// AddAvatarImageAndUsernameToMessages indicates an expected call of AddAvatarImageAndUsernameToMessages.
func (mr *MockServMockRecorder) AddAvatarImageAndUsernameToMessages(msgsRaw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAvatarImageAndUsernameToMessages", reflect.TypeOf((*MockServ)(nil).AddAvatarImageAndUsernameToMessages), msgsRaw)
}

// DecodeAuthToken mocks base method.
func (m *MockServ) DecodeAuthToken(token string) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeAuthToken", token)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DecodeAuthToken indicates an expected call of DecodeAuthToken.
func (mr *MockServMockRecorder) DecodeAuthToken(token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthToken", reflect.TypeOf((*MockServ)(nil).DecodeAuthToken), token)
}

// Delete mocks base method.
func (m *MockServ) Delete(ID domain.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockServMockRecorder) Delete(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServ)(nil).Delete), ID)
}

// Edit mocks base method.
func (m *MockServ) Edit(ID domain.UUID, newMessage, newImageUrl string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Edit", ID, newMessage, newImageUrl)
	ret0, _ := ret[0].(error)
	return ret0
}

// Edit indicates an expected call of Edit.
func (mr *MockServMockRecorder) Edit(ID, newMessage, newImageUrl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Edit", reflect.TypeOf((*MockServ)(nil).Edit), ID, newMessage, newImageUrl)
}

// EncodeAuthToken mocks base method.
func (m *MockServ) EncodeAuthToken(userID int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncodeAuthToken", userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EncodeAuthToken indicates an expected call of EncodeAuthToken.
func (mr *MockServMockRecorder) EncodeAuthToken(userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeAuthToken", reflect.TypeOf((*MockServ)(nil).EncodeAuthToken), userID)
}

// ExtractAuthToken mocks base method.
func (m *MockServ) ExtractAuthToken(r *http.Request) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractAuthToken", r)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExtractAuthToken indicates an expected call of ExtractAuthToken.
func (mr *MockServMockRecorder) ExtractAuthToken(r any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtractAuthToken", reflect.TypeOf((*MockServ)(nil).ExtractAuthToken), r)
}

// FindOne mocks base method.
func (m *MockServ) FindOne(username, email string) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", username, email)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockServMockRecorder) FindOne(username, email any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockServ)(nil).FindOne), username, email)
}

// Get mocks base method.
func (m *MockServ) Get(userID int, isFast bool) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", userID, isFast)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockServMockRecorder) Get(userID, isFast any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockServ)(nil).Get), userID, isFast)
}

// GetAll mocks base method.
func (m *MockServ) GetAll(username string) ([]domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAll", username)
	ret0, _ := ret[0].([]domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAll indicates an expected call of GetAll.
func (mr *MockServMockRecorder) GetAll(username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockServ)(nil).GetAll), username)
}

// GetMessage mocks base method.
func (m *MockServ) GetMessage(ID domain.UUID) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMessage", ID)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessage indicates an expected call of GetMessage.
func (mr *MockServMockRecorder) GetMessage(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessage", reflect.TypeOf((*MockServ)(nil).GetMessage), ID)
}

// GetPinned mocks base method.
func (m *MockServ) GetPinned(chatID int) ([]domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPinned", chatID)
	ret0, _ := ret[0].([]domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPinned indicates an expected call of GetPinned.
func (mr *MockServMockRecorder) GetPinned(chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPinned", reflect.TypeOf((*MockServ)(nil).GetPinned), chatID)
}

// GetRaw mocks base method.
func (m *MockServ) GetRaw(ID domain.UUID) (domain.RawMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRaw", ID)
	ret0, _ := ret[0].(domain.RawMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRaw indicates an expected call of GetRaw.
func (mr *MockServMockRecorder) GetRaw(ID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRaw", reflect.TypeOf((*MockServ)(nil).GetRaw), ID)
}

// GetSome mocks base method.
func (m *MockServ) GetSome(chatID, offset, limit int) ([]domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSome", chatID, offset, limit)
	ret0, _ := ret[0].([]domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSome indicates an expected call of GetSome.
func (mr *MockServMockRecorder) GetSome(chatID, offset, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSome", reflect.TypeOf((*MockServ)(nil).GetSome), chatID, offset, limit)
}

// GetVerificated mocks base method.
func (m *MockServ) GetVerificated(userID int) (domain.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVerificated", userID)
	ret0, _ := ret[0].(domain.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVerificated indicates an expected call of GetVerificated.
func (mr *MockServMockRecorder) GetVerificated(userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerificated", reflect.TypeOf((*MockServ)(nil).GetVerificated), userID)
}

// HashPassword mocks base method.
func (m *MockServ) HashPassword(p string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HashPassword", p)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HashPassword indicates an expected call of HashPassword.
func (mr *MockServMockRecorder) HashPassword(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashPassword", reflect.TypeOf((*MockServ)(nil).HashPassword), p)
}

// Pin mocks base method.
func (m *MockServ) Pin(chatID, userID int, messageID domain.UUID) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pin", chatID, userID, messageID)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pin indicates an expected call of Pin.
func (mr *MockServMockRecorder) Pin(chatID, userID, messageID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pin", reflect.TypeOf((*MockServ)(nil).Pin), chatID, userID, messageID)
}

// Register mocks base method.
func (m *MockServ) Register(userData domain.UserRegister) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Register", userData)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Register indicates an expected call of Register.
func (mr *MockServMockRecorder) Register(userData any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockServ)(nil).Register), userData)
}

// SendMessage mocks base method.
func (m *MockServ) SendMessage(userID, chatID int, message domain.SendMessage) (domain.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessage", userID, chatID, message)
	ret0, _ := ret[0].(domain.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockServMockRecorder) SendMessage(userID, chatID, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockServ)(nil).SendMessage), userID, chatID, message)
}

// Unpin mocks base method.
func (m *MockServ) Unpin(chatID int, messageID domain.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unpin", chatID, messageID)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unpin indicates an expected call of Unpin.
func (mr *MockServMockRecorder) Unpin(chatID, messageID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unpin", reflect.TypeOf((*MockServ)(nil).Unpin), chatID, messageID)
}

// VerifyHashedPassword mocks base method.
func (m *MockServ) VerifyHashedPassword(p, hp string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyHashedPassword", p, hp)
	ret0, _ := ret[0].(bool)
	return ret0
}

// VerifyHashedPassword indicates an expected call of VerifyHashedPassword.
func (mr *MockServMockRecorder) VerifyHashedPassword(p, hp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyHashedPassword", reflect.TypeOf((*MockServ)(nil).VerifyHashedPassword), p, hp)
}