// 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 }