// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/internal/notification/handlers (interfaces: Queries)
//
// Generated by this command:
//
//	mockgen -typed -package mock -destination ./mock/queries.mock.go . Queries
//

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

import (
	context "context"
	reflect "reflect"

	jose "github.com/go-jose/go-jose/v4"
	authz "github.com/zitadel/zitadel/internal/api/authz"
	domain "github.com/zitadel/zitadel/internal/domain"
	query "github.com/zitadel/zitadel/internal/query"
	gomock "go.uber.org/mock/gomock"
	language "golang.org/x/text/language"
)

// MockQueries is a mock of Queries interface.
type MockQueries struct {
	ctrl     *gomock.Controller
	recorder *MockQueriesMockRecorder
	isgomock struct{}
}

// MockQueriesMockRecorder is the mock recorder for MockQueries.
type MockQueriesMockRecorder struct {
	mock *MockQueries
}

// NewMockQueries creates a new mock instance.
func NewMockQueries(ctrl *gomock.Controller) *MockQueries {
	mock := &MockQueries{ctrl: ctrl}
	mock.recorder = &MockQueriesMockRecorder{mock}
	return mock
}

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

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

// ActiveInstances indicates an expected call of ActiveInstances.
func (mr *MockQueriesMockRecorder) ActiveInstances() *MockQueriesActiveInstancesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActiveInstances", reflect.TypeOf((*MockQueries)(nil).ActiveInstances))
	return &MockQueriesActiveInstancesCall{Call: call}
}

// MockQueriesActiveInstancesCall wrap *gomock.Call
type MockQueriesActiveInstancesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesActiveInstancesCall) Return(arg0 []string) *MockQueriesActiveInstancesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesActiveInstancesCall) Do(f func() []string) *MockQueriesActiveInstancesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesActiveInstancesCall) DoAndReturn(f func() []string) *MockQueriesActiveInstancesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ActiveLabelPolicyByOrg mocks base method.
func (m *MockQueries) ActiveLabelPolicyByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (*query.LabelPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActiveLabelPolicyByOrg", ctx, orgID, withOwnerRemoved)
	ret0, _ := ret[0].(*query.LabelPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ActiveLabelPolicyByOrg indicates an expected call of ActiveLabelPolicyByOrg.
func (mr *MockQueriesMockRecorder) ActiveLabelPolicyByOrg(ctx, orgID, withOwnerRemoved any) *MockQueriesActiveLabelPolicyByOrgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActiveLabelPolicyByOrg", reflect.TypeOf((*MockQueries)(nil).ActiveLabelPolicyByOrg), ctx, orgID, withOwnerRemoved)
	return &MockQueriesActiveLabelPolicyByOrgCall{Call: call}
}

// MockQueriesActiveLabelPolicyByOrgCall wrap *gomock.Call
type MockQueriesActiveLabelPolicyByOrgCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesActiveLabelPolicyByOrgCall) Return(arg0 *query.LabelPolicy, arg1 error) *MockQueriesActiveLabelPolicyByOrgCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesActiveLabelPolicyByOrgCall) Do(f func(context.Context, string, bool) (*query.LabelPolicy, error)) *MockQueriesActiveLabelPolicyByOrgCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesActiveLabelPolicyByOrgCall) DoAndReturn(f func(context.Context, string, bool) (*query.LabelPolicy, error)) *MockQueriesActiveLabelPolicyByOrgCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CustomTextListByTemplate mocks base method.
func (m *MockQueries) CustomTextListByTemplate(ctx context.Context, aggregateID, template string, withOwnerRemoved bool) (*query.CustomTexts, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CustomTextListByTemplate", ctx, aggregateID, template, withOwnerRemoved)
	ret0, _ := ret[0].(*query.CustomTexts)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CustomTextListByTemplate indicates an expected call of CustomTextListByTemplate.
func (mr *MockQueriesMockRecorder) CustomTextListByTemplate(ctx, aggregateID, template, withOwnerRemoved any) *MockQueriesCustomTextListByTemplateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CustomTextListByTemplate", reflect.TypeOf((*MockQueries)(nil).CustomTextListByTemplate), ctx, aggregateID, template, withOwnerRemoved)
	return &MockQueriesCustomTextListByTemplateCall{Call: call}
}

// MockQueriesCustomTextListByTemplateCall wrap *gomock.Call
type MockQueriesCustomTextListByTemplateCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesCustomTextListByTemplateCall) Return(arg0 *query.CustomTexts, arg1 error) *MockQueriesCustomTextListByTemplateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesCustomTextListByTemplateCall) Do(f func(context.Context, string, string, bool) (*query.CustomTexts, error)) *MockQueriesCustomTextListByTemplateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesCustomTextListByTemplateCall) DoAndReturn(f func(context.Context, string, string, bool) (*query.CustomTexts, error)) *MockQueriesCustomTextListByTemplateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetActiveSigningWebKey mocks base method.
func (m *MockQueries) GetActiveSigningWebKey(ctx context.Context) (*jose.JSONWebKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveSigningWebKey", ctx)
	ret0, _ := ret[0].(*jose.JSONWebKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveSigningWebKey indicates an expected call of GetActiveSigningWebKey.
func (mr *MockQueriesMockRecorder) GetActiveSigningWebKey(ctx any) *MockQueriesGetActiveSigningWebKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveSigningWebKey", reflect.TypeOf((*MockQueries)(nil).GetActiveSigningWebKey), ctx)
	return &MockQueriesGetActiveSigningWebKeyCall{Call: call}
}

// MockQueriesGetActiveSigningWebKeyCall wrap *gomock.Call
type MockQueriesGetActiveSigningWebKeyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesGetActiveSigningWebKeyCall) Return(arg0 *jose.JSONWebKey, arg1 error) *MockQueriesGetActiveSigningWebKeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesGetActiveSigningWebKeyCall) Do(f func(context.Context) (*jose.JSONWebKey, error)) *MockQueriesGetActiveSigningWebKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesGetActiveSigningWebKeyCall) DoAndReturn(f func(context.Context) (*jose.JSONWebKey, error)) *MockQueriesGetActiveSigningWebKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetDefaultLanguage mocks base method.
func (m *MockQueries) GetDefaultLanguage(ctx context.Context) language.Tag {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultLanguage", ctx)
	ret0, _ := ret[0].(language.Tag)
	return ret0
}

// GetDefaultLanguage indicates an expected call of GetDefaultLanguage.
func (mr *MockQueriesMockRecorder) GetDefaultLanguage(ctx any) *MockQueriesGetDefaultLanguageCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultLanguage", reflect.TypeOf((*MockQueries)(nil).GetDefaultLanguage), ctx)
	return &MockQueriesGetDefaultLanguageCall{Call: call}
}

// MockQueriesGetDefaultLanguageCall wrap *gomock.Call
type MockQueriesGetDefaultLanguageCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesGetDefaultLanguageCall) Return(arg0 language.Tag) *MockQueriesGetDefaultLanguageCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesGetDefaultLanguageCall) Do(f func(context.Context) language.Tag) *MockQueriesGetDefaultLanguageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesGetDefaultLanguageCall) DoAndReturn(f func(context.Context) language.Tag) *MockQueriesGetDefaultLanguageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetInstanceRestrictions mocks base method.
func (m *MockQueries) GetInstanceRestrictions(ctx context.Context) (query.Restrictions, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceRestrictions", ctx)
	ret0, _ := ret[0].(query.Restrictions)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceRestrictions indicates an expected call of GetInstanceRestrictions.
func (mr *MockQueriesMockRecorder) GetInstanceRestrictions(ctx any) *MockQueriesGetInstanceRestrictionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceRestrictions", reflect.TypeOf((*MockQueries)(nil).GetInstanceRestrictions), ctx)
	return &MockQueriesGetInstanceRestrictionsCall{Call: call}
}

// MockQueriesGetInstanceRestrictionsCall wrap *gomock.Call
type MockQueriesGetInstanceRestrictionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesGetInstanceRestrictionsCall) Return(restrictions query.Restrictions, err error) *MockQueriesGetInstanceRestrictionsCall {
	c.Call = c.Call.Return(restrictions, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesGetInstanceRestrictionsCall) Do(f func(context.Context) (query.Restrictions, error)) *MockQueriesGetInstanceRestrictionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesGetInstanceRestrictionsCall) DoAndReturn(f func(context.Context) (query.Restrictions, error)) *MockQueriesGetInstanceRestrictionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetNotifyUserByID mocks base method.
func (m *MockQueries) GetNotifyUserByID(ctx context.Context, shouldTriggered bool, userID string) (*query.NotifyUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotifyUserByID", ctx, shouldTriggered, userID)
	ret0, _ := ret[0].(*query.NotifyUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotifyUserByID indicates an expected call of GetNotifyUserByID.
func (mr *MockQueriesMockRecorder) GetNotifyUserByID(ctx, shouldTriggered, userID any) *MockQueriesGetNotifyUserByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifyUserByID", reflect.TypeOf((*MockQueries)(nil).GetNotifyUserByID), ctx, shouldTriggered, userID)
	return &MockQueriesGetNotifyUserByIDCall{Call: call}
}

// MockQueriesGetNotifyUserByIDCall wrap *gomock.Call
type MockQueriesGetNotifyUserByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesGetNotifyUserByIDCall) Return(arg0 *query.NotifyUser, arg1 error) *MockQueriesGetNotifyUserByIDCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesGetNotifyUserByIDCall) Do(f func(context.Context, bool, string) (*query.NotifyUser, error)) *MockQueriesGetNotifyUserByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesGetNotifyUserByIDCall) DoAndReturn(f func(context.Context, bool, string) (*query.NotifyUser, error)) *MockQueriesGetNotifyUserByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceByID mocks base method.
func (m *MockQueries) InstanceByID(ctx context.Context, id string) (authz.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceByID", ctx, id)
	ret0, _ := ret[0].(authz.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InstanceByID indicates an expected call of InstanceByID.
func (mr *MockQueriesMockRecorder) InstanceByID(ctx, id any) *MockQueriesInstanceByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceByID", reflect.TypeOf((*MockQueries)(nil).InstanceByID), ctx, id)
	return &MockQueriesInstanceByIDCall{Call: call}
}

// MockQueriesInstanceByIDCall wrap *gomock.Call
type MockQueriesInstanceByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesInstanceByIDCall) Return(instance authz.Instance, err error) *MockQueriesInstanceByIDCall {
	c.Call = c.Call.Return(instance, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesInstanceByIDCall) Do(f func(context.Context, string) (authz.Instance, error)) *MockQueriesInstanceByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesInstanceByIDCall) DoAndReturn(f func(context.Context, string) (authz.Instance, error)) *MockQueriesInstanceByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MailTemplateByOrg mocks base method.
func (m *MockQueries) MailTemplateByOrg(ctx context.Context, orgID string, withOwnerRemoved bool) (*query.MailTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MailTemplateByOrg", ctx, orgID, withOwnerRemoved)
	ret0, _ := ret[0].(*query.MailTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MailTemplateByOrg indicates an expected call of MailTemplateByOrg.
func (mr *MockQueriesMockRecorder) MailTemplateByOrg(ctx, orgID, withOwnerRemoved any) *MockQueriesMailTemplateByOrgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MailTemplateByOrg", reflect.TypeOf((*MockQueries)(nil).MailTemplateByOrg), ctx, orgID, withOwnerRemoved)
	return &MockQueriesMailTemplateByOrgCall{Call: call}
}

// MockQueriesMailTemplateByOrgCall wrap *gomock.Call
type MockQueriesMailTemplateByOrgCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesMailTemplateByOrgCall) Return(arg0 *query.MailTemplate, arg1 error) *MockQueriesMailTemplateByOrgCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesMailTemplateByOrgCall) Do(f func(context.Context, string, bool) (*query.MailTemplate, error)) *MockQueriesMailTemplateByOrgCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesMailTemplateByOrgCall) DoAndReturn(f func(context.Context, string, bool) (*query.MailTemplate, error)) *MockQueriesMailTemplateByOrgCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NotificationPolicyByOrg mocks base method.
func (m *MockQueries) NotificationPolicyByOrg(ctx context.Context, shouldTriggerBulk bool, orgID string, withOwnerRemoved bool) (*query.NotificationPolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotificationPolicyByOrg", ctx, shouldTriggerBulk, orgID, withOwnerRemoved)
	ret0, _ := ret[0].(*query.NotificationPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotificationPolicyByOrg indicates an expected call of NotificationPolicyByOrg.
func (mr *MockQueriesMockRecorder) NotificationPolicyByOrg(ctx, shouldTriggerBulk, orgID, withOwnerRemoved any) *MockQueriesNotificationPolicyByOrgCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotificationPolicyByOrg", reflect.TypeOf((*MockQueries)(nil).NotificationPolicyByOrg), ctx, shouldTriggerBulk, orgID, withOwnerRemoved)
	return &MockQueriesNotificationPolicyByOrgCall{Call: call}
}

// MockQueriesNotificationPolicyByOrgCall wrap *gomock.Call
type MockQueriesNotificationPolicyByOrgCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesNotificationPolicyByOrgCall) Return(arg0 *query.NotificationPolicy, arg1 error) *MockQueriesNotificationPolicyByOrgCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesNotificationPolicyByOrgCall) Do(f func(context.Context, bool, string, bool) (*query.NotificationPolicy, error)) *MockQueriesNotificationPolicyByOrgCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesNotificationPolicyByOrgCall) DoAndReturn(f func(context.Context, bool, string, bool) (*query.NotificationPolicy, error)) *MockQueriesNotificationPolicyByOrgCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NotificationProviderByIDAndType mocks base method.
func (m *MockQueries) NotificationProviderByIDAndType(ctx context.Context, aggID string, providerType domain.NotificationProviderType) (*query.DebugNotificationProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotificationProviderByIDAndType", ctx, aggID, providerType)
	ret0, _ := ret[0].(*query.DebugNotificationProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NotificationProviderByIDAndType indicates an expected call of NotificationProviderByIDAndType.
func (mr *MockQueriesMockRecorder) NotificationProviderByIDAndType(ctx, aggID, providerType any) *MockQueriesNotificationProviderByIDAndTypeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotificationProviderByIDAndType", reflect.TypeOf((*MockQueries)(nil).NotificationProviderByIDAndType), ctx, aggID, providerType)
	return &MockQueriesNotificationProviderByIDAndTypeCall{Call: call}
}

// MockQueriesNotificationProviderByIDAndTypeCall wrap *gomock.Call
type MockQueriesNotificationProviderByIDAndTypeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesNotificationProviderByIDAndTypeCall) Return(arg0 *query.DebugNotificationProvider, arg1 error) *MockQueriesNotificationProviderByIDAndTypeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesNotificationProviderByIDAndTypeCall) Do(f func(context.Context, string, domain.NotificationProviderType) (*query.DebugNotificationProvider, error)) *MockQueriesNotificationProviderByIDAndTypeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesNotificationProviderByIDAndTypeCall) DoAndReturn(f func(context.Context, string, domain.NotificationProviderType) (*query.DebugNotificationProvider, error)) *MockQueriesNotificationProviderByIDAndTypeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SMSProviderConfigActive mocks base method.
func (m *MockQueries) SMSProviderConfigActive(ctx context.Context, resourceOwner string) (*query.SMSConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMSProviderConfigActive", ctx, resourceOwner)
	ret0, _ := ret[0].(*query.SMSConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SMSProviderConfigActive indicates an expected call of SMSProviderConfigActive.
func (mr *MockQueriesMockRecorder) SMSProviderConfigActive(ctx, resourceOwner any) *MockQueriesSMSProviderConfigActiveCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMSProviderConfigActive", reflect.TypeOf((*MockQueries)(nil).SMSProviderConfigActive), ctx, resourceOwner)
	return &MockQueriesSMSProviderConfigActiveCall{Call: call}
}

// MockQueriesSMSProviderConfigActiveCall wrap *gomock.Call
type MockQueriesSMSProviderConfigActiveCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesSMSProviderConfigActiveCall) Return(config *query.SMSConfig, err error) *MockQueriesSMSProviderConfigActiveCall {
	c.Call = c.Call.Return(config, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesSMSProviderConfigActiveCall) Do(f func(context.Context, string) (*query.SMSConfig, error)) *MockQueriesSMSProviderConfigActiveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesSMSProviderConfigActiveCall) DoAndReturn(f func(context.Context, string) (*query.SMSConfig, error)) *MockQueriesSMSProviderConfigActiveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SMTPConfigActive mocks base method.
func (m *MockQueries) SMTPConfigActive(ctx context.Context, resourceOwner string) (*query.SMTPConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMTPConfigActive", ctx, resourceOwner)
	ret0, _ := ret[0].(*query.SMTPConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SMTPConfigActive indicates an expected call of SMTPConfigActive.
func (mr *MockQueriesMockRecorder) SMTPConfigActive(ctx, resourceOwner any) *MockQueriesSMTPConfigActiveCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMTPConfigActive", reflect.TypeOf((*MockQueries)(nil).SMTPConfigActive), ctx, resourceOwner)
	return &MockQueriesSMTPConfigActiveCall{Call: call}
}

// MockQueriesSMTPConfigActiveCall wrap *gomock.Call
type MockQueriesSMTPConfigActiveCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesSMTPConfigActiveCall) Return(arg0 *query.SMTPConfig, arg1 error) *MockQueriesSMTPConfigActiveCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesSMTPConfigActiveCall) Do(f func(context.Context, string) (*query.SMTPConfig, error)) *MockQueriesSMTPConfigActiveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesSMTPConfigActiveCall) DoAndReturn(f func(context.Context, string) (*query.SMTPConfig, error)) *MockQueriesSMTPConfigActiveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SearchInstanceDomains mocks base method.
func (m *MockQueries) SearchInstanceDomains(ctx context.Context, queries *query.InstanceDomainSearchQueries) (*query.InstanceDomains, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchInstanceDomains", ctx, queries)
	ret0, _ := ret[0].(*query.InstanceDomains)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchInstanceDomains indicates an expected call of SearchInstanceDomains.
func (mr *MockQueriesMockRecorder) SearchInstanceDomains(ctx, queries any) *MockQueriesSearchInstanceDomainsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchInstanceDomains", reflect.TypeOf((*MockQueries)(nil).SearchInstanceDomains), ctx, queries)
	return &MockQueriesSearchInstanceDomainsCall{Call: call}
}

// MockQueriesSearchInstanceDomainsCall wrap *gomock.Call
type MockQueriesSearchInstanceDomainsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesSearchInstanceDomainsCall) Return(arg0 *query.InstanceDomains, arg1 error) *MockQueriesSearchInstanceDomainsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesSearchInstanceDomainsCall) Do(f func(context.Context, *query.InstanceDomainSearchQueries) (*query.InstanceDomains, error)) *MockQueriesSearchInstanceDomainsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesSearchInstanceDomainsCall) DoAndReturn(f func(context.Context, *query.InstanceDomainSearchQueries) (*query.InstanceDomains, error)) *MockQueriesSearchInstanceDomainsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SearchMilestones mocks base method.
func (m *MockQueries) SearchMilestones(ctx context.Context, instanceIDs []string, queries *query.MilestonesSearchQueries) (*query.Milestones, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchMilestones", ctx, instanceIDs, queries)
	ret0, _ := ret[0].(*query.Milestones)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchMilestones indicates an expected call of SearchMilestones.
func (mr *MockQueriesMockRecorder) SearchMilestones(ctx, instanceIDs, queries any) *MockQueriesSearchMilestonesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchMilestones", reflect.TypeOf((*MockQueries)(nil).SearchMilestones), ctx, instanceIDs, queries)
	return &MockQueriesSearchMilestonesCall{Call: call}
}

// MockQueriesSearchMilestonesCall wrap *gomock.Call
type MockQueriesSearchMilestonesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesSearchMilestonesCall) Return(arg0 *query.Milestones, arg1 error) *MockQueriesSearchMilestonesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesSearchMilestonesCall) Do(f func(context.Context, []string, *query.MilestonesSearchQueries) (*query.Milestones, error)) *MockQueriesSearchMilestonesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesSearchMilestonesCall) DoAndReturn(f func(context.Context, []string, *query.MilestonesSearchQueries) (*query.Milestones, error)) *MockQueriesSearchMilestonesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SessionByID mocks base method.
func (m *MockQueries) SessionByID(ctx context.Context, shouldTriggerBulk bool, id, sessionToken string, check domain.PermissionCheck) (*query.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SessionByID", ctx, shouldTriggerBulk, id, sessionToken, check)
	ret0, _ := ret[0].(*query.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SessionByID indicates an expected call of SessionByID.
func (mr *MockQueriesMockRecorder) SessionByID(ctx, shouldTriggerBulk, id, sessionToken, check any) *MockQueriesSessionByIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionByID", reflect.TypeOf((*MockQueries)(nil).SessionByID), ctx, shouldTriggerBulk, id, sessionToken, check)
	return &MockQueriesSessionByIDCall{Call: call}
}

// MockQueriesSessionByIDCall wrap *gomock.Call
type MockQueriesSessionByIDCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQueriesSessionByIDCall) Return(arg0 *query.Session, arg1 error) *MockQueriesSessionByIDCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQueriesSessionByIDCall) Do(f func(context.Context, bool, string, string, domain.PermissionCheck) (*query.Session, error)) *MockQueriesSessionByIDCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQueriesSessionByIDCall) DoAndReturn(f func(context.Context, bool, string, string, domain.PermissionCheck) (*query.Session, error)) *MockQueriesSessionByIDCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}