zitadel/backend/v3/domain/mock/branding_settings.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: BrandingSettingsRepository)
//
// Generated by this command:
//
//	mockgen -typed -package domainmock -destination ./mock/branding_settings.mock.go . BrandingSettingsRepository
//

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

import (
	context "context"
	url "net/url"
	reflect "reflect"
	time "time"

	domain "github.com/zitadel/zitadel/backend/v3/domain"
	database "github.com/zitadel/zitadel/backend/v3/storage/database"
	json "github.com/zitadel/zitadel/backend/v3/storage/database/json"
	gomock "go.uber.org/mock/gomock"
)

// MockBrandingSettingsRepository is a mock of BrandingSettingsRepository interface.
type MockBrandingSettingsRepository struct {
	ctrl     *gomock.Controller
	recorder *MockBrandingSettingsRepositoryMockRecorder
	isgomock struct{}
}

// MockBrandingSettingsRepositoryMockRecorder is the mock recorder for MockBrandingSettingsRepository.
type MockBrandingSettingsRepositoryMockRecorder struct {
	mock *MockBrandingSettingsRepository
}

// NewMockBrandingSettingsRepository creates a new mock instance.
func NewMockBrandingSettingsRepository(ctrl *gomock.Controller) *MockBrandingSettingsRepository {
	mock := &MockBrandingSettingsRepository{ctrl: ctrl}
	mock.recorder = &MockBrandingSettingsRepositoryMockRecorder{mock}
	return mock
}

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

// Activate mocks base method.
func (m *MockBrandingSettingsRepository) Activate(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Activate", ctx, client, condition)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Activate indicates an expected call of Activate.
func (mr *MockBrandingSettingsRepositoryMockRecorder) Activate(ctx, client, condition any) *MockBrandingSettingsRepositoryActivateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Activate), ctx, client, condition)
	return &MockBrandingSettingsRepositoryActivateCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryActivateCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryActivateCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryActivateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryActivateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryActivateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryActivateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ActivateAt mocks base method.
func (m *MockBrandingSettingsRepository) ActivateAt(ctx context.Context, client database.QueryExecutor, condition database.Condition, updatedAt time.Time) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateAt", ctx, client, condition, updatedAt)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ActivateAt indicates an expected call of ActivateAt.
func (mr *MockBrandingSettingsRepositoryMockRecorder) ActivateAt(ctx, client, condition, updatedAt any) *MockBrandingSettingsRepositoryActivateAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateAt", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).ActivateAt), ctx, client, condition, updatedAt)
	return &MockBrandingSettingsRepositoryActivateAtCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryActivateAtCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryActivateAtCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryActivateAtCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, time.Time) (int64, error)) *MockBrandingSettingsRepositoryActivateAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryActivateAtCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, time.Time) (int64, error)) *MockBrandingSettingsRepositoryActivateAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreatedAtColumn mocks base method.
func (m *MockBrandingSettingsRepository) CreatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// CreatedAtColumn indicates an expected call of CreatedAtColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) CreatedAtColumn() *MockBrandingSettingsRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).CreatedAtColumn))
	return &MockBrandingSettingsRepositoryCreatedAtColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Delete mocks base method.
func (m *MockBrandingSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, client, condition)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockBrandingSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockBrandingSettingsRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Delete), ctx, client, condition)
	return &MockBrandingSettingsRepositoryDeleteCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryDeleteCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryDeleteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryDeleteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockBrandingSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.BrandingSettings, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*domain.BrandingSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockBrandingSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockBrandingSettingsRepositoryGetCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Get), varargs...)
	return &MockBrandingSettingsRepositoryGetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryGetCall) Return(arg0 *domain.BrandingSettings, arg1 error) *MockBrandingSettingsRepositoryGetCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryGetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryGetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// IDColumn mocks base method.
func (m *MockBrandingSettingsRepository) IDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// IDColumn indicates an expected call of IDColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) IDColumn() *MockBrandingSettingsRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).IDColumn))
	return &MockBrandingSettingsRepositoryIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// IDCondition indicates an expected call of IDCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) IDCondition(id any) *MockBrandingSettingsRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).IDCondition), id)
	return &MockBrandingSettingsRepositoryIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockBrandingSettingsRepositoryIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockBrandingSettingsRepositoryIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InstanceIDColumn mocks base method.
func (m *MockBrandingSettingsRepository) InstanceIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstanceIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// InstanceIDColumn indicates an expected call of InstanceIDColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) InstanceIDColumn() *MockBrandingSettingsRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).InstanceIDColumn))
	return &MockBrandingSettingsRepositoryInstanceIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockBrandingSettingsRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).InstanceIDCondition), id)
	return &MockBrandingSettingsRepositoryInstanceIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// List mocks base method.
func (m *MockBrandingSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.BrandingSettings, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].([]*domain.BrandingSettings)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockBrandingSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockBrandingSettingsRepositoryListCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).List), varargs...)
	return &MockBrandingSettingsRepositoryListCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryListCall) Return(arg0 []*domain.BrandingSettings, arg1 error) *MockBrandingSettingsRepositoryListCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryListCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryListCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OrganizationIDColumn mocks base method.
func (m *MockBrandingSettingsRepository) OrganizationIDColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrganizationIDColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// OrganizationIDColumn indicates an expected call of OrganizationIDColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockBrandingSettingsRepositoryOrganizationIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).OrganizationIDColumn))
	return &MockBrandingSettingsRepositoryOrganizationIDColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// OrganizationIDCondition indicates an expected call of OrganizationIDCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockBrandingSettingsRepositoryOrganizationIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).OrganizationIDCondition), id)
	return &MockBrandingSettingsRepositoryOrganizationIDConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyColumns mocks base method.
func (m *MockBrandingSettingsRepository) PrimaryKeyColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns.
func (mr *MockBrandingSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).PrimaryKeyColumns))
	return &MockBrandingSettingsRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PrimaryKeyCondition mocks base method.
func (m *MockBrandingSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id)
	return &MockBrandingSettingsRepositoryPrimaryKeyConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Set mocks base method.
func (m *MockBrandingSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.BrandingSettings) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, client, settings)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockBrandingSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockBrandingSettingsRepositorySetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Set), ctx, client, settings)
	return &MockBrandingSettingsRepositorySetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetCall) Return(arg0 error) *MockBrandingSettingsRepositorySetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.BrandingSettings) error) *MockBrandingSettingsRepositorySetCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.BrandingSettings) error) *MockBrandingSettingsRepositorySetCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetBackgroundColorDark indicates an expected call of SetBackgroundColorDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetBackgroundColorDark(value any) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackgroundColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetBackgroundColorDark), value)
	return &MockBrandingSettingsRepositorySetBackgroundColorDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetBackgroundColorLight indicates an expected call of SetBackgroundColorLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetBackgroundColorLight(value any) *MockBrandingSettingsRepositorySetBackgroundColorLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackgroundColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetBackgroundColorLight), value)
	return &MockBrandingSettingsRepositorySetBackgroundColorLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetColumns mocks base method.
func (m *MockBrandingSettingsRepository) SetColumns(ctx context.Context, client database.QueryExecutor, settings *domain.Settings, changes ...database.Change) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, client, settings}
	for _, a := range changes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetColumns", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetColumns indicates an expected call of SetColumns.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetColumns(ctx, client, settings any, changes ...any) *MockBrandingSettingsRepositorySetColumnsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, settings}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetColumns), varargs...)
	return &MockBrandingSettingsRepositorySetColumnsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetColumnsCall) Return(arg0 error) *MockBrandingSettingsRepositorySetColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetColumnsCall) Do(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockBrandingSettingsRepositorySetColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetColumnsCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockBrandingSettingsRepositorySetColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDisableWatermark mocks base method.
func (m *MockBrandingSettingsRepository) SetDisableWatermark(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDisableWatermark", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetDisableWatermark indicates an expected call of SetDisableWatermark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetDisableWatermark(value any) *MockBrandingSettingsRepositorySetDisableWatermarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableWatermark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetDisableWatermark), value)
	return &MockBrandingSettingsRepositorySetDisableWatermarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetErrorMsgPopup mocks base method.
func (m *MockBrandingSettingsRepository) SetErrorMsgPopup(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetErrorMsgPopup", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetErrorMsgPopup indicates an expected call of SetErrorMsgPopup.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetErrorMsgPopup(value any) *MockBrandingSettingsRepositorySetErrorMsgPopupCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetErrorMsgPopup", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetErrorMsgPopup), value)
	return &MockBrandingSettingsRepositorySetErrorMsgPopupCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetFontColorDark indicates an expected call of SetFontColorDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontColorDark(value any) *MockBrandingSettingsRepositorySetFontColorDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontColorDark), value)
	return &MockBrandingSettingsRepositorySetFontColorDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetFontColorLight indicates an expected call of SetFontColorLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontColorLight(value any) *MockBrandingSettingsRepositorySetFontColorLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontColorLight), value)
	return &MockBrandingSettingsRepositorySetFontColorLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetFontColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetFontColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetFontColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetFontURL mocks base method.
func (m *MockBrandingSettingsRepository) SetFontURL(value url.URL) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFontURL", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetFontURL indicates an expected call of SetFontURL.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontURL(value any) *MockBrandingSettingsRepositorySetFontURLCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontURL", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontURL), value)
	return &MockBrandingSettingsRepositorySetFontURLCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetFontURLCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetFontURLCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetFontURLCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetHideLoginNameSuffix mocks base method.
func (m *MockBrandingSettingsRepository) SetHideLoginNameSuffix(value bool) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHideLoginNameSuffix", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetHideLoginNameSuffix indicates an expected call of SetHideLoginNameSuffix.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetHideLoginNameSuffix(value any) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHideLoginNameSuffix", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetHideLoginNameSuffix), value)
	return &MockBrandingSettingsRepositorySetHideLoginNameSuffixCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIconURLDark mocks base method.
func (m *MockBrandingSettingsRepository) SetIconURLDark(value url.URL) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIconURLDark", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetIconURLDark indicates an expected call of SetIconURLDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetIconURLDark(value any) *MockBrandingSettingsRepositorySetIconURLDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIconURLDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetIconURLDark), value)
	return &MockBrandingSettingsRepositorySetIconURLDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIconURLLight mocks base method.
func (m *MockBrandingSettingsRepository) SetIconURLLight(value url.URL) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIconURLLight", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetIconURLLight indicates an expected call of SetIconURLLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetIconURLLight(value any) *MockBrandingSettingsRepositorySetIconURLLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIconURLLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetIconURLLight), value)
	return &MockBrandingSettingsRepositorySetIconURLLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetIconURLLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetIconURLLightCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetIconURLLightCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLogoURLDark mocks base method.
func (m *MockBrandingSettingsRepository) SetLogoURLDark(value url.URL) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogoURLDark", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetLogoURLDark indicates an expected call of SetLogoURLDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetLogoURLDark(value any) *MockBrandingSettingsRepositorySetLogoURLDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogoURLDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetLogoURLDark), value)
	return &MockBrandingSettingsRepositorySetLogoURLDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLogoURLLight mocks base method.
func (m *MockBrandingSettingsRepository) SetLogoURLLight(value url.URL) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLogoURLLight", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetLogoURLLight indicates an expected call of SetLogoURLLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetLogoURLLight(value any) *MockBrandingSettingsRepositorySetLogoURLLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogoURLLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetLogoURLLight), value)
	return &MockBrandingSettingsRepositorySetLogoURLLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPrimaryColorDark indicates an expected call of SetPrimaryColorDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetPrimaryColorDark(value any) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrimaryColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetPrimaryColorDark), value)
	return &MockBrandingSettingsRepositorySetPrimaryColorDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetPrimaryColorLight indicates an expected call of SetPrimaryColorLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetPrimaryColorLight(value any) *MockBrandingSettingsRepositorySetPrimaryColorLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrimaryColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetPrimaryColorLight), value)
	return &MockBrandingSettingsRepositorySetPrimaryColorLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSettingFields mocks base method.
func (m *MockBrandingSettingsRepository) SetSettingFields(value domain.BrandingSettingsAttributes) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSettingFields", value)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetSettingFields indicates an expected call of SetSettingFields.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockBrandingSettingsRepositorySetSettingFieldsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetSettingFields), value)
	return &MockBrandingSettingsRepositorySetSettingFieldsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) Do(f func(domain.BrandingSettingsAttributes) database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.BrandingSettingsAttributes) database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetThemeMode mocks base method.
func (m *MockBrandingSettingsRepository) SetThemeMode(value domain.BrandingPolicyThemeMode) json.JsonUpdate {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetThemeMode", value)
	ret0, _ := ret[0].(json.JsonUpdate)
	return ret0
}

// SetThemeMode indicates an expected call of SetThemeMode.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetThemeMode(value any) *MockBrandingSettingsRepositorySetThemeModeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetThemeMode", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetThemeMode), value)
	return &MockBrandingSettingsRepositorySetThemeModeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetThemeModeCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetThemeModeCall) Do(f func(domain.BrandingPolicyThemeMode) json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetThemeModeCall) DoAndReturn(f func(domain.BrandingPolicyThemeMode) json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetUpdatedAt mocks base method.
func (m *MockBrandingSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetUpdatedAt indicates an expected call of SetUpdatedAt.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockBrandingSettingsRepositorySetUpdatedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetUpdatedAt), updatedAt)
	return &MockBrandingSettingsRepositorySetUpdatedAtCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetWarnColorDark indicates an expected call of SetWarnColorDark.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetWarnColorDark(value any) *MockBrandingSettingsRepositorySetWarnColorDarkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWarnColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetWarnColorDark), value)
	return &MockBrandingSettingsRepositorySetWarnColorDarkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetWarnColorLight indicates an expected call of SetWarnColorLight.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SetWarnColorLight(value any) *MockBrandingSettingsRepositorySetWarnColorLightCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWarnColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetWarnColorLight), value)
	return &MockBrandingSettingsRepositorySetWarnColorLightCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SettingsColumn mocks base method.
func (m *MockBrandingSettingsRepository) SettingsColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SettingsColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// SettingsColumn indicates an expected call of SettingsColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) SettingsColumn() *MockBrandingSettingsRepositorySettingsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SettingsColumn))
	return &MockBrandingSettingsRepositorySettingsColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositorySettingsColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositorySettingsColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositorySettingsColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StateColumn mocks base method.
func (m *MockBrandingSettingsRepository) StateColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// StateColumn indicates an expected call of StateColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) StateColumn() *MockBrandingSettingsRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).StateColumn))
	return &MockBrandingSettingsRepositoryStateColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryStateColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryStateColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryStateColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StateCondition mocks base method.
func (m *MockBrandingSettingsRepository) StateCondition(typ domain.SettingState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateCondition", typ)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// StateCondition indicates an expected call of StateCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) StateCondition(typ any) *MockBrandingSettingsRepositoryStateConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).StateCondition), typ)
	return &MockBrandingSettingsRepositoryStateConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryStateConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryStateConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryStateConditionCall) Do(f func(domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryStateConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryStateConditionCall) DoAndReturn(f func(domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryStateConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TypeColumn mocks base method.
func (m *MockBrandingSettingsRepository) TypeColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// TypeColumn indicates an expected call of TypeColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) TypeColumn() *MockBrandingSettingsRepositoryTypeColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).TypeColumn))
	return &MockBrandingSettingsRepositoryTypeColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryTypeColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryTypeColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryTypeColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TypeCondition mocks base method.
func (m *MockBrandingSettingsRepository) TypeCondition(typ domain.SettingType) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TypeCondition", typ)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// TypeCondition indicates an expected call of TypeCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) TypeCondition(typ any) *MockBrandingSettingsRepositoryTypeConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).TypeCondition), typ)
	return &MockBrandingSettingsRepositoryTypeConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryTypeConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryTypeConditionCall) Do(f func(domain.SettingType) database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryTypeConditionCall) DoAndReturn(f func(domain.SettingType) database.Condition) *MockBrandingSettingsRepositoryTypeConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UniqueColumns mocks base method.
func (m *MockBrandingSettingsRepository) UniqueColumns() []database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueColumns")
	ret0, _ := ret[0].([]database.Column)
	return ret0
}

// UniqueColumns indicates an expected call of UniqueColumns.
func (mr *MockBrandingSettingsRepositoryMockRecorder) UniqueColumns() *MockBrandingSettingsRepositoryUniqueColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UniqueColumns))
	return &MockBrandingSettingsRepositoryUniqueColumnsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UniqueCondition mocks base method.
func (m *MockBrandingSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UniqueCondition indicates an expected call of UniqueCondition.
func (mr *MockBrandingSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockBrandingSettingsRepositoryUniqueConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state)
	return &MockBrandingSettingsRepositoryUniqueConditionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdatedAtColumn mocks base method.
func (m *MockBrandingSettingsRepository) UpdatedAtColumn() database.Column {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtColumn")
	ret0, _ := ret[0].(database.Column)
	return ret0
}

// UpdatedAtColumn indicates an expected call of UpdatedAtColumn.
func (mr *MockBrandingSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockBrandingSettingsRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UpdatedAtColumn))
	return &MockBrandingSettingsRepositoryUpdatedAtColumnCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}