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

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

// 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"
	gomock "go.uber.org/mock/gomock"
)

// MockIDPIntentRepository is a mock of IDPIntentRepository interface.
type MockIDPIntentRepository struct {
	ctrl     *gomock.Controller
	recorder *MockIDPIntentRepositoryMockRecorder
	isgomock struct{}
}

// MockIDPIntentRepositoryMockRecorder is the mock recorder for MockIDPIntentRepository.
type MockIDPIntentRepositoryMockRecorder struct {
	mock *MockIDPIntentRepository
}

// NewMockIDPIntentRepository creates a new mock instance.
func NewMockIDPIntentRepository(ctrl *gomock.Controller) *MockIDPIntentRepository {
	mock := &MockIDPIntentRepository{ctrl: ctrl}
	mock.recorder = &MockIDPIntentRepositoryMockRecorder{mock}
	return mock
}

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

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

// AssertionColumn indicates an expected call of AssertionColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) AssertionColumn() *MockIDPIntentRepositoryAssertionColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssertionColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).AssertionColumn))
	return &MockIDPIntentRepositoryAssertionColumnCall{Call: call}
}

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

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

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

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

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

// Create indicates an expected call of Create.
func (mr *MockIDPIntentRepositoryMockRecorder) Create(ctx, client, intent any) *MockIDPIntentRepositoryCreateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIDPIntentRepository)(nil).Create), ctx, client, intent)
	return &MockIDPIntentRepositoryCreateCall{Call: call}
}

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

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

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

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

// CreatedAtColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) CreatedAtColumn() *MockIDPIntentRepositoryCreatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).CreatedAtColumn))
	return &MockIDPIntentRepositoryCreatedAtColumnCall{Call: call}
}

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

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

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

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

// CreatedAtCondition mocks base method.
func (m *MockIDPIntentRepository) CreatedAtCondition(op database.NumberOperation, createdAt time.Time) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatedAtCondition", op, createdAt)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// CreatedAtCondition indicates an expected call of CreatedAtCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) CreatedAtCondition(op, createdAt any) *MockIDPIntentRepositoryCreatedAtConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).CreatedAtCondition), op, createdAt)
	return &MockIDPIntentRepositoryCreatedAtConditionCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositoryCreatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockIDPIntentRepositoryCreatedAtConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositoryCreatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockIDPIntentRepositoryCreatedAtConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Delete mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) Delete(ctx, client, condition any) *MockIDPIntentRepositoryDeleteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIDPIntentRepository)(nil).Delete), ctx, client, condition)
	return &MockIDPIntentRepositoryDeleteCall{Call: call}
}

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

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

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

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

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

// ExpiresAtColumn indicates an expected call of ExpiresAtColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) ExpiresAtColumn() *MockIDPIntentRepositoryExpiresAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpiresAtColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).ExpiresAtColumn))
	return &MockIDPIntentRepositoryExpiresAtColumnCall{Call: call}
}

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

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

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

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

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

// FailReasonColumn indicates an expected call of FailReasonColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) FailReasonColumn() *MockIDPIntentRepositoryFailReasonColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailReasonColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).FailReasonColumn))
	return &MockIDPIntentRepositoryFailReasonColumnCall{Call: call}
}

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

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

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

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

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

// FailedAtColumn indicates an expected call of FailedAtColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) FailedAtColumn() *MockIDPIntentRepositoryFailedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailedAtColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).FailedAtColumn))
	return &MockIDPIntentRepositoryFailedAtColumnCall{Call: call}
}

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

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

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

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

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

// FailureURLColumn indicates an expected call of FailureURLColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) FailureURLColumn() *MockIDPIntentRepositoryFailureURLColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FailureURLColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).FailureURLColumn))
	return &MockIDPIntentRepositoryFailureURLColumnCall{Call: call}
}

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

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

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

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

// Get mocks base method.
func (m *MockIDPIntentRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.IDPIntent, 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.IDPIntent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// IDColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) IDColumn() *MockIDPIntentRepositoryIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDColumn))
	return &MockIDPIntentRepositoryIDColumnCall{Call: call}
}

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

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

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

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

// IDCondition mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) IDCondition(id any) *MockIDPIntentRepositoryIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDCondition), id)
	return &MockIDPIntentRepositoryIDConditionCall{Call: call}
}

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

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

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

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

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

// IDPAccessTokenColumn indicates an expected call of IDPAccessTokenColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPAccessTokenColumn() *MockIDPIntentRepositoryIDPAccessTokenColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPAccessTokenColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPAccessTokenColumn))
	return &MockIDPIntentRepositoryIDPAccessTokenColumnCall{Call: call}
}

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

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

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

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

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

// IDPArgumentsColumn indicates an expected call of IDPArgumentsColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPArgumentsColumn() *MockIDPIntentRepositoryIDPArgumentsColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPArgumentsColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPArgumentsColumn))
	return &MockIDPIntentRepositoryIDPArgumentsColumnCall{Call: call}
}

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

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

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

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

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

// IDPEntryAttributesColumn indicates an expected call of IDPEntryAttributesColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPEntryAttributesColumn() *MockIDPIntentRepositoryIDPEntryAttributesColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPEntryAttributesColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPEntryAttributesColumn))
	return &MockIDPIntentRepositoryIDPEntryAttributesColumnCall{Call: call}
}

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

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

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

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

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

// IDPIDColumn indicates an expected call of IDPIDColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPIDColumn() *MockIDPIntentRepositoryIDPIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPIDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPIDColumn))
	return &MockIDPIntentRepositoryIDPIDColumnCall{Call: call}
}

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

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

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

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

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

// IDPIDCondition indicates an expected call of IDPIDCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPIDCondition(idpID any) *MockIDPIntentRepositoryIDPIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPIDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPIDCondition), idpID)
	return &MockIDPIntentRepositoryIDPIDConditionCall{Call: call}
}

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

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

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

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

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

// IDPIDTokenColumn indicates an expected call of IDPIDTokenColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPIDTokenColumn() *MockIDPIntentRepositoryIDPIDTokenColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPIDTokenColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPIDTokenColumn))
	return &MockIDPIntentRepositoryIDPIDTokenColumnCall{Call: call}
}

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

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

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

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

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

// IDPUserColumn indicates an expected call of IDPUserColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPUserColumn() *MockIDPIntentRepositoryIDPUserColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPUserColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPUserColumn))
	return &MockIDPIntentRepositoryIDPUserColumnCall{Call: call}
}

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

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

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

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

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

// IDPUserIDColumn indicates an expected call of IDPUserIDColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPUserIDColumn() *MockIDPIntentRepositoryIDPUserIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPUserIDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPUserIDColumn))
	return &MockIDPIntentRepositoryIDPUserIDColumnCall{Call: call}
}

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

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

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

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

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

// IDPUserIDCondition indicates an expected call of IDPUserIDCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPUserIDCondition(idpUserID any) *MockIDPIntentRepositoryIDPUserIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPUserIDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPUserIDCondition), idpUserID)
	return &MockIDPIntentRepositoryIDPUserIDConditionCall{Call: call}
}

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

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

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

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

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

// IDPUsernameColumn indicates an expected call of IDPUsernameColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPUsernameColumn() *MockIDPIntentRepositoryIDPUsernameColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPUsernameColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPUsernameColumn))
	return &MockIDPIntentRepositoryIDPUsernameColumnCall{Call: call}
}

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

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

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

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

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

// IDPUsernameCondition indicates an expected call of IDPUsernameCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) IDPUsernameCondition(idpUsername any) *MockIDPIntentRepositoryIDPUsernameConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDPUsernameCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).IDPUsernameCondition), idpUsername)
	return &MockIDPIntentRepositoryIDPUsernameConditionCall{Call: call}
}

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

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

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

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

// InstanceIDColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) InstanceIDColumn() *MockIDPIntentRepositoryInstanceIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).InstanceIDColumn))
	return &MockIDPIntentRepositoryInstanceIDColumnCall{Call: call}
}

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

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

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

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

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

// InstanceIDCondition indicates an expected call of InstanceIDCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) InstanceIDCondition(instanceID any) *MockIDPIntentRepositoryInstanceIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).InstanceIDCondition), instanceID)
	return &MockIDPIntentRepositoryInstanceIDConditionCall{Call: call}
}

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

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

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

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

// PrimaryKeyColumns mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) PrimaryKeyColumns() *MockIDPIntentRepositoryPrimaryKeyColumnsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockIDPIntentRepository)(nil).PrimaryKeyColumns))
	return &MockIDPIntentRepositoryPrimaryKeyColumnsCall{Call: call}
}

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

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

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

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

// PrimaryKeyCondition mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockIDPIntentRepositoryPrimaryKeyConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).PrimaryKeyCondition), instanceID, id)
	return &MockIDPIntentRepositoryPrimaryKeyConditionCall{Call: call}
}

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

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

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

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

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

// RequestIDColumn indicates an expected call of RequestIDColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) RequestIDColumn() *MockIDPIntentRepositoryRequestIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestIDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).RequestIDColumn))
	return &MockIDPIntentRepositoryRequestIDColumnCall{Call: call}
}

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

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

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

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

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

// RequestIDCondition indicates an expected call of RequestIDCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) RequestIDCondition(requestID any) *MockIDPIntentRepositoryRequestIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestIDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).RequestIDCondition), requestID)
	return &MockIDPIntentRepositoryRequestIDConditionCall{Call: call}
}

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

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

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

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

// SetAssertion mocks base method.
func (m *MockIDPIntentRepository) SetAssertion(assertion []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAssertion", assertion)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetAssertion indicates an expected call of SetAssertion.
func (mr *MockIDPIntentRepositoryMockRecorder) SetAssertion(assertion any) *MockIDPIntentRepositorySetAssertionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAssertion", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetAssertion), assertion)
	return &MockIDPIntentRepositorySetAssertionCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetAssertionCall) Do(f func([]byte) database.Change) *MockIDPIntentRepositorySetAssertionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetAssertionCall) DoAndReturn(f func([]byte) database.Change) *MockIDPIntentRepositorySetAssertionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetExpiresAt indicates an expected call of SetExpiresAt.
func (mr *MockIDPIntentRepositoryMockRecorder) SetExpiresAt(expiration any) *MockIDPIntentRepositorySetExpiresAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiresAt", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetExpiresAt), expiration)
	return &MockIDPIntentRepositorySetExpiresAtCall{Call: call}
}

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

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

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

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

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

// SetFailReason indicates an expected call of SetFailReason.
func (mr *MockIDPIntentRepositoryMockRecorder) SetFailReason(reason any) *MockIDPIntentRepositorySetFailReasonCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFailReason", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetFailReason), reason)
	return &MockIDPIntentRepositorySetFailReasonCall{Call: call}
}

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

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

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

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

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

// SetFailedAt indicates an expected call of SetFailedAt.
func (mr *MockIDPIntentRepositoryMockRecorder) SetFailedAt(failedAt any) *MockIDPIntentRepositorySetFailedAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFailedAt", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetFailedAt), failedAt)
	return &MockIDPIntentRepositorySetFailedAtCall{Call: call}
}

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

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

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

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

// SetFailureURL mocks base method.
func (m *MockIDPIntentRepository) SetFailureURL(failureURL url.URL) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetFailureURL", failureURL)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetFailureURL indicates an expected call of SetFailureURL.
func (mr *MockIDPIntentRepositoryMockRecorder) SetFailureURL(failureURL any) *MockIDPIntentRepositorySetFailureURLCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFailureURL", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetFailureURL), failureURL)
	return &MockIDPIntentRepositorySetFailureURLCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetFailureURLCall) Do(f func(url.URL) database.Change) *MockIDPIntentRepositorySetFailureURLCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetFailureURLCall) DoAndReturn(f func(url.URL) database.Change) *MockIDPIntentRepositorySetFailureURLCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIDPAccessToken mocks base method.
func (m *MockIDPIntentRepository) SetIDPAccessToken(idpAccessToken []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIDPAccessToken", idpAccessToken)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetIDPAccessToken indicates an expected call of SetIDPAccessToken.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPAccessToken(idpAccessToken any) *MockIDPIntentRepositorySetIDPAccessTokenCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPAccessToken", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPAccessToken), idpAccessToken)
	return &MockIDPIntentRepositorySetIDPAccessTokenCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetIDPAccessTokenCall) Do(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPAccessTokenCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetIDPAccessTokenCall) DoAndReturn(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPAccessTokenCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIDPArguments mocks base method.
func (m *MockIDPIntentRepository) SetIDPArguments(idpArguments []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIDPArguments", idpArguments)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetIDPArguments indicates an expected call of SetIDPArguments.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPArguments(idpArguments any) *MockIDPIntentRepositorySetIDPArgumentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPArguments", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPArguments), idpArguments)
	return &MockIDPIntentRepositorySetIDPArgumentsCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetIDPArgumentsCall) Do(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPArgumentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetIDPArgumentsCall) DoAndReturn(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPArgumentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetIDPEntryAttributes mocks base method.
func (m *MockIDPIntentRepository) SetIDPEntryAttributes(idpEntryAttributes []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIDPEntryAttributes", idpEntryAttributes)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetIDPEntryAttributes indicates an expected call of SetIDPEntryAttributes.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPEntryAttributes(idpEntryAttributes any) *MockIDPIntentRepositorySetIDPEntryAttributesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPEntryAttributes", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPEntryAttributes), idpEntryAttributes)
	return &MockIDPIntentRepositorySetIDPEntryAttributesCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetIDPEntryAttributesCall) Do(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPEntryAttributesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetIDPEntryAttributesCall) DoAndReturn(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPEntryAttributesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetIDPID indicates an expected call of SetIDPID.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPID(idpID any) *MockIDPIntentRepositorySetIDPIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPID", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPID), idpID)
	return &MockIDPIntentRepositorySetIDPIDCall{Call: call}
}

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

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

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

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

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

// SetIDPIDToken indicates an expected call of SetIDPIDToken.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPIDToken(idpIDToken any) *MockIDPIntentRepositorySetIDPIDTokenCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPIDToken", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPIDToken), idpIDToken)
	return &MockIDPIntentRepositorySetIDPIDTokenCall{Call: call}
}

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

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

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

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

// SetIDPUser mocks base method.
func (m *MockIDPIntentRepository) SetIDPUser(idpUser []byte) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIDPUser", idpUser)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetIDPUser indicates an expected call of SetIDPUser.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPUser(idpUser any) *MockIDPIntentRepositorySetIDPUserCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPUser", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPUser), idpUser)
	return &MockIDPIntentRepositorySetIDPUserCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetIDPUserCall) Do(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPUserCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetIDPUserCall) DoAndReturn(f func([]byte) database.Change) *MockIDPIntentRepositorySetIDPUserCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetIDPUserID indicates an expected call of SetIDPUserID.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPUserID(idpUserID any) *MockIDPIntentRepositorySetIDPUserIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPUserID", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPUserID), idpUserID)
	return &MockIDPIntentRepositorySetIDPUserIDCall{Call: call}
}

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

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

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

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

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

// SetIDPUsername indicates an expected call of SetIDPUsername.
func (mr *MockIDPIntentRepositoryMockRecorder) SetIDPUsername(idpUsername any) *MockIDPIntentRepositorySetIDPUsernameCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIDPUsername", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetIDPUsername), idpUsername)
	return &MockIDPIntentRepositorySetIDPUsernameCall{Call: call}
}

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

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

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

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

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

// SetRequestID indicates an expected call of SetRequestID.
func (mr *MockIDPIntentRepositoryMockRecorder) SetRequestID(requestID any) *MockIDPIntentRepositorySetRequestIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequestID", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetRequestID), requestID)
	return &MockIDPIntentRepositorySetRequestIDCall{Call: call}
}

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

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

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

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

// SetState mocks base method.
func (m *MockIDPIntentRepository) SetState(state domain.IDPIntentState) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetState", state)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetState indicates an expected call of SetState.
func (mr *MockIDPIntentRepositoryMockRecorder) SetState(state any) *MockIDPIntentRepositorySetStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetState", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetState), state)
	return &MockIDPIntentRepositorySetStateCall{Call: call}
}

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

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

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

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

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

// SetSucceededAt indicates an expected call of SetSucceededAt.
func (mr *MockIDPIntentRepositoryMockRecorder) SetSucceededAt(succeededAt any) *MockIDPIntentRepositorySetSucceededAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSucceededAt", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetSucceededAt), succeededAt)
	return &MockIDPIntentRepositorySetSucceededAtCall{Call: call}
}

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

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

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

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

// SetSuccessURL mocks base method.
func (m *MockIDPIntentRepository) SetSuccessURL(successURL url.URL) database.Change {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSuccessURL", successURL)
	ret0, _ := ret[0].(database.Change)
	return ret0
}

// SetSuccessURL indicates an expected call of SetSuccessURL.
func (mr *MockIDPIntentRepositoryMockRecorder) SetSuccessURL(successURL any) *MockIDPIntentRepositorySetSuccessURLCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSuccessURL", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetSuccessURL), successURL)
	return &MockIDPIntentRepositorySetSuccessURLCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositorySetSuccessURLCall) Do(f func(url.URL) database.Change) *MockIDPIntentRepositorySetSuccessURLCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositorySetSuccessURLCall) DoAndReturn(f func(url.URL) database.Change) *MockIDPIntentRepositorySetSuccessURLCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// SetUserID indicates an expected call of SetUserID.
func (mr *MockIDPIntentRepositoryMockRecorder) SetUserID(userID any) *MockIDPIntentRepositorySetUserIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserID", reflect.TypeOf((*MockIDPIntentRepository)(nil).SetUserID), userID)
	return &MockIDPIntentRepositorySetUserIDCall{Call: call}
}

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

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

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

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

// StateColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) StateColumn() *MockIDPIntentRepositoryStateColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).StateColumn))
	return &MockIDPIntentRepositoryStateColumnCall{Call: call}
}

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

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

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

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

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

// StateCondition indicates an expected call of StateCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) StateCondition(state any) *MockIDPIntentRepositoryStateConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).StateCondition), state)
	return &MockIDPIntentRepositoryStateConditionCall{Call: call}
}

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

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

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

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

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

// SucceededAtColumn indicates an expected call of SucceededAtColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) SucceededAtColumn() *MockIDPIntentRepositorySucceededAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SucceededAtColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).SucceededAtColumn))
	return &MockIDPIntentRepositorySucceededAtColumnCall{Call: call}
}

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

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

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

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

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

// SuccessURLColumn indicates an expected call of SuccessURLColumn.
func (mr *MockIDPIntentRepositoryMockRecorder) SuccessURLColumn() *MockIDPIntentRepositorySuccessURLColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuccessURLColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).SuccessURLColumn))
	return &MockIDPIntentRepositorySuccessURLColumnCall{Call: call}
}

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

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

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

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

// Update mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) Update(ctx, client, condition any, changes ...any) *MockIDPIntentRepositoryUpdateCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, client, condition}, changes...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIDPIntentRepository)(nil).Update), varargs...)
	return &MockIDPIntentRepositoryUpdateCall{Call: call}
}

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

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

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

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

// UpdatedAtColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) UpdatedAtColumn() *MockIDPIntentRepositoryUpdatedAtColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).UpdatedAtColumn))
	return &MockIDPIntentRepositoryUpdatedAtColumnCall{Call: call}
}

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

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

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

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

// UpdatedAtCondition mocks base method.
func (m *MockIDPIntentRepository) UpdatedAtCondition(op database.NumberOperation, updatedAt time.Time) database.Condition {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatedAtCondition", op, updatedAt)
	ret0, _ := ret[0].(database.Condition)
	return ret0
}

// UpdatedAtCondition indicates an expected call of UpdatedAtCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) UpdatedAtCondition(op, updatedAt any) *MockIDPIntentRepositoryUpdatedAtConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).UpdatedAtCondition), op, updatedAt)
	return &MockIDPIntentRepositoryUpdatedAtConditionCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockIDPIntentRepositoryUpdatedAtConditionCall) Do(f func(database.NumberOperation, time.Time) database.Condition) *MockIDPIntentRepositoryUpdatedAtConditionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockIDPIntentRepositoryUpdatedAtConditionCall) DoAndReturn(f func(database.NumberOperation, time.Time) database.Condition) *MockIDPIntentRepositoryUpdatedAtConditionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UserIDColumn mocks base method.
func (m *MockIDPIntentRepository) 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 *MockIDPIntentRepositoryMockRecorder) UserIDColumn() *MockIDPIntentRepositoryUserIDColumnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDColumn", reflect.TypeOf((*MockIDPIntentRepository)(nil).UserIDColumn))
	return &MockIDPIntentRepositoryUserIDColumnCall{Call: call}
}

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

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

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

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

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

// UserIDCondition indicates an expected call of UserIDCondition.
func (mr *MockIDPIntentRepositoryMockRecorder) UserIDCondition(userID any) *MockIDPIntentRepositoryUserIDConditionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserIDCondition", reflect.TypeOf((*MockIDPIntentRepository)(nil).UserIDCondition), userID)
	return &MockIDPIntentRepositoryUserIDConditionCall{Call: call}
}

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

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

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

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