// Code generated by MockGen. DO NOT EDIT. // Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: UserIdentityProviderLinkRepository) // // Generated by this command: // // mockgen -typed -package domainmock -destination ./mock/user_identity_provider_link.mock.go . UserIdentityProviderLinkRepository // // Package domainmock is a generated GoMock package. package domainmock import ( context "context" reflect "reflect" time "time" domain "github.com/zitadel/zitadel/backend/v3/domain" database "github.com/zitadel/zitadel/backend/v3/storage/database" gomock "go.uber.org/mock/gomock" ) // MockUserIdentityProviderLinkRepository is a mock of UserIdentityProviderLinkRepository interface. type MockUserIdentityProviderLinkRepository struct { ctrl *gomock.Controller recorder *MockUserIdentityProviderLinkRepositoryMockRecorder isgomock struct{} } // MockUserIdentityProviderLinkRepositoryMockRecorder is the mock recorder for MockUserIdentityProviderLinkRepository. type MockUserIdentityProviderLinkRepositoryMockRecorder struct { mock *MockUserIdentityProviderLinkRepository } // NewMockUserIdentityProviderLinkRepository creates a new mock instance. func NewMockUserIdentityProviderLinkRepository(ctrl *gomock.Controller) *MockUserIdentityProviderLinkRepository { mock := &MockUserIdentityProviderLinkRepository{ctrl: ctrl} mock.recorder = &MockUserIdentityProviderLinkRepositoryMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. func (m *MockUserIdentityProviderLinkRepository) EXPECT() *MockUserIdentityProviderLinkRepositoryMockRecorder { return m.recorder } // Create mocks base method. func (m *MockUserIdentityProviderLinkRepository) Create(ctx context.Context, client database.QueryExecutor, link *domain.UserIdentityProviderLink) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Create", ctx, client, link) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Create(ctx, client, link any) *MockUserIdentityProviderLinkRepositoryCreateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Create), ctx, client, link) return &MockUserIdentityProviderLinkRepositoryCreateCall{Call: call} } // MockUserIdentityProviderLinkRepositoryCreateCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryCreateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryCreateCall) Return(arg0 error) *MockUserIdentityProviderLinkRepositoryCreateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryCreateCall) Do(f func(context.Context, database.QueryExecutor, *domain.UserIdentityProviderLink) error) *MockUserIdentityProviderLinkRepositoryCreateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryCreateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.UserIdentityProviderLink) error) *MockUserIdentityProviderLinkRepositoryCreateCall { c.Call = c.Call.DoAndReturn(f) return c } // CreatedAtColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) CreatedAtColumn() *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).CreatedAtColumn)) return &MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryCreatedAtColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // Delete mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) Delete(ctx, client, condition any) *MockUserIdentityProviderLinkRepositoryDeleteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Delete), ctx, client, condition) return &MockUserIdentityProviderLinkRepositoryDeleteCall{Call: call} } // MockUserIdentityProviderLinkRepositoryDeleteCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryDeleteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockUserIdentityProviderLinkRepositoryDeleteCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserIdentityProviderLinkRepositoryDeleteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockUserIdentityProviderLinkRepositoryDeleteCall { c.Call = c.Call.DoAndReturn(f) return c } // Get mocks base method. func (m *MockUserIdentityProviderLinkRepository) Get(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) (*domain.UserIdentityProviderLink, error) { m.ctrl.T.Helper() varargs := []any{ctx, client, condition} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Get", varargs...) ret0, _ := ret[0].(*domain.UserIdentityProviderLink) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Get(ctx, client, condition any, opts ...any) *MockUserIdentityProviderLinkRepositoryGetCall { mr.mock.ctrl.T.Helper() varargs := append([]any{ctx, client, condition}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Get), varargs...) return &MockUserIdentityProviderLinkRepositoryGetCall{Call: call} } // MockUserIdentityProviderLinkRepositoryGetCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryGetCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryGetCall) Return(arg0 *domain.UserIdentityProviderLink, arg1 error) *MockUserIdentityProviderLinkRepositoryGetCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) (*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryGetCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) (*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryGetCall { c.Call = c.Call.DoAndReturn(f) return c } // IdentityProviderIDColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) IdentityProviderIDColumn() database.Column { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IdentityProviderIDColumn") ret0, _ := ret[0].(database.Column) return ret0 } // IdentityProviderIDColumn indicates an expected call of IdentityProviderIDColumn. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) IdentityProviderIDColumn() *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityProviderIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).IdentityProviderIDColumn)) return &MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // IdentityProviderIDCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) IdentityProviderIDCondition(op database.TextOperation, id string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IdentityProviderIDCondition", op, id) ret0, _ := ret[0].(database.Condition) return ret0 } // IdentityProviderIDCondition indicates an expected call of IdentityProviderIDCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) IdentityProviderIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IdentityProviderIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).IdentityProviderIDCondition), op, id) return &MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryIdentityProviderIDConditionCall { c.Call = c.Call.DoAndReturn(f) return c } // InstanceIDColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) InstanceIDColumn() *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).InstanceIDColumn)) return &MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryInstanceIDColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // InstanceIDCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) InstanceIDCondition(op database.TextOperation, id string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "InstanceIDCondition", op, id) ret0, _ := ret[0].(database.Condition) return ret0 } // InstanceIDCondition indicates an expected call of InstanceIDCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) InstanceIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).InstanceIDCondition), op, id) return &MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryInstanceIDConditionCall { c.Call = c.Call.DoAndReturn(f) return c } // List mocks base method. func (m *MockUserIdentityProviderLinkRepository) List(ctx context.Context, client database.QueryExecutor, condition database.Condition, opts ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error) { m.ctrl.T.Helper() varargs := []any{ctx, client, condition} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "List", varargs...) ret0, _ := ret[0].([]*domain.UserIdentityProviderLink) ret1, _ := ret[1].(error) return ret0, ret1 } // List indicates an expected call of List. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) List(ctx, client, condition any, opts ...any) *MockUserIdentityProviderLinkRepositoryListCall { mr.mock.ctrl.T.Helper() varargs := append([]any{ctx, client, condition}, opts...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).List), varargs...) return &MockUserIdentityProviderLinkRepositoryListCall{Call: call} } // MockUserIdentityProviderLinkRepositoryListCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryListCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryListCall) Return(arg0 []*domain.UserIdentityProviderLink, arg1 error) *MockUserIdentityProviderLinkRepositoryListCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryListCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.QueryOption) ([]*domain.UserIdentityProviderLink, error)) *MockUserIdentityProviderLinkRepositoryListCall { c.Call = c.Call.DoAndReturn(f) return c } // PrimaryKeyColumns mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) PrimaryKeyColumns() *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).PrimaryKeyColumns)) return &MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall{Call: call} } // MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockUserIdentityProviderLinkRepositoryPrimaryKeyColumnsCall { c.Call = c.Call.DoAndReturn(f) return c } // PrimaryKeyCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) PrimaryKeyCondition(instanceID, idpID, providedID string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, idpID, providedID) ret0, _ := ret[0].(database.Condition) return ret0 } // PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) PrimaryKeyCondition(instanceID, idpID, providedID any) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).PrimaryKeyCondition), instanceID, idpID, providedID) return &MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) Do(f func(string, string, string) database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string, string) database.Condition) *MockUserIdentityProviderLinkRepositoryPrimaryKeyConditionCall { c.Call = c.Call.DoAndReturn(f) return c } // ProvidedIDColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) ProvidedIDColumn() database.Column { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvidedIDColumn") ret0, _ := ret[0].(database.Column) return ret0 } // ProvidedIDColumn indicates an expected call of ProvidedIDColumn. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedIDColumn() *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedIDColumn)) return &MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedIDColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // ProvidedIDCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) ProvidedIDCondition(op database.TextOperation, id string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvidedIDCondition", op, id) ret0, _ := ret[0].(database.Condition) return ret0 } // ProvidedIDCondition indicates an expected call of ProvidedIDCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedIDCondition), op, id) return &MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedIDConditionCall { c.Call = c.Call.DoAndReturn(f) return c } // ProvidedUsernameColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) ProvidedUsernameColumn() database.Column { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvidedUsernameColumn") ret0, _ := ret[0].(database.Column) return ret0 } // ProvidedUsernameColumn indicates an expected call of ProvidedUsernameColumn. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedUsernameColumn() *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedUsernameColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedUsernameColumn)) return &MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryProvidedUsernameColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // ProvidedUsernameCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) ProvidedUsernameCondition(op database.TextOperation, username string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ProvidedUsernameCondition", op, username) ret0, _ := ret[0].(database.Condition) return ret0 } // ProvidedUsernameCondition indicates an expected call of ProvidedUsernameCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) ProvidedUsernameCondition(op, username any) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvidedUsernameCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).ProvidedUsernameCondition), op, username) return &MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryProvidedUsernameConditionCall { c.Call = c.Call.DoAndReturn(f) return c } // SetProvidedUserID mocks base method. func (m *MockUserIdentityProviderLinkRepository) SetProvidedUserID(providedID string) database.Change { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetProvidedUserID", providedID) ret0, _ := ret[0].(database.Change) return ret0 } // SetProvidedUserID indicates an expected call of SetProvidedUserID. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) SetProvidedUserID(providedID any) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProvidedUserID", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetProvidedUserID), providedID) return &MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall{Call: call} } // MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) Do(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall) DoAndReturn(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUserIDCall { c.Call = c.Call.DoAndReturn(f) return c } // SetProvidedUsername mocks base method. func (m *MockUserIdentityProviderLinkRepository) SetProvidedUsername(username string) database.Change { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetProvidedUsername", username) ret0, _ := ret[0].(database.Change) return ret0 } // SetProvidedUsername indicates an expected call of SetProvidedUsername. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) SetProvidedUsername(username any) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProvidedUsername", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetProvidedUsername), username) return &MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall{Call: call} } // MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) Do(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall) DoAndReturn(f func(string) database.Change) *MockUserIdentityProviderLinkRepositorySetProvidedUsernameCall { c.Call = c.Call.DoAndReturn(f) return c } // SetUpdatedAt mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).SetUpdatedAt), updatedAt) return &MockUserIdentityProviderLinkRepositorySetUpdatedAtCall{Call: call} } // MockUserIdentityProviderLinkRepositorySetUpdatedAtCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositorySetUpdatedAtCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) Do(f func(time.Time) database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall) DoAndReturn(f func(time.Time) database.Change) *MockUserIdentityProviderLinkRepositorySetUpdatedAtCall { c.Call = c.Call.DoAndReturn(f) return c } // Update mocks base method. func (m *MockUserIdentityProviderLinkRepository) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) { m.ctrl.T.Helper() varargs := []any{ctx, client, condition} for _, a := range changes { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Update", varargs...) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } // Update indicates an expected call of Update. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockUserIdentityProviderLinkRepositoryUpdateCall { mr.mock.ctrl.T.Helper() varargs := append([]any{ctx, client, condition}, changes...) call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).Update), varargs...) return &MockUserIdentityProviderLinkRepositoryUpdateCall{Call: call} } // MockUserIdentityProviderLinkRepositoryUpdateCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryUpdateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) Return(arg0 int64, arg1 error) *MockUserIdentityProviderLinkRepositoryUpdateCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserIdentityProviderLinkRepositoryUpdateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryUpdateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, ...database.Change) (int64, error)) *MockUserIdentityProviderLinkRepositoryUpdateCall { c.Call = c.Call.DoAndReturn(f) return c } // UpdatedAtColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) 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 *MockUserIdentityProviderLinkRepositoryMockRecorder) UpdatedAtColumn() *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UpdatedAtColumn)) return &MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUpdatedAtColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // UserIDColumn mocks base method. func (m *MockUserIdentityProviderLinkRepository) UserIDColumn() database.Column { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UserIDColumn") ret0, _ := ret[0].(database.Column) return ret0 } // UserIDColumn indicates an expected call of UserIDColumn. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) UserIDColumn() *MockUserIdentityProviderLinkRepositoryUserIDColumnCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UserIDColumn)) return &MockUserIdentityProviderLinkRepositoryUserIDColumnCall{Call: call} } // MockUserIdentityProviderLinkRepositoryUserIDColumnCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryUserIDColumnCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) Return(arg0 database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) Do(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryUserIDColumnCall) DoAndReturn(f func() database.Column) *MockUserIdentityProviderLinkRepositoryUserIDColumnCall { c.Call = c.Call.DoAndReturn(f) return c } // UserIDCondition mocks base method. func (m *MockUserIdentityProviderLinkRepository) UserIDCondition(op database.TextOperation, id string) database.Condition { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UserIDCondition", op, id) ret0, _ := ret[0].(database.Condition) return ret0 } // UserIDCondition indicates an expected call of UserIDCondition. func (mr *MockUserIdentityProviderLinkRepositoryMockRecorder) UserIDCondition(op, id any) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockUserIdentityProviderLinkRepository)(nil).UserIDCondition), op, id) return &MockUserIdentityProviderLinkRepositoryUserIDConditionCall{Call: call} } // MockUserIdentityProviderLinkRepositoryUserIDConditionCall wrap *gomock.Call type MockUserIdentityProviderLinkRepositoryUserIDConditionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) Return(arg0 database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) Do(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockUserIdentityProviderLinkRepositoryUserIDConditionCall) DoAndReturn(f func(database.TextOperation, string) database.Condition) *MockUserIdentityProviderLinkRepositoryUserIDConditionCall { c.Call = c.Call.DoAndReturn(f) return c }