cloud_migration_service_api.go

// Code generated by mockery. DO NOT EDIT.

package mockadmin

import (
	context "context"

	admin "go.mongodb.org/atlas-sdk/v20231115008/admin"

	http "net/http"

	mock "github.com/stretchr/testify/mock"
)

// CloudMigrationServiceApi is an autogenerated mock type for the CloudMigrationServiceApi type
type CloudMigrationServiceApi struct {
	mock.Mock
}

type CloudMigrationServiceApi_Expecter struct {
	mock *mock.Mock
}

func (_m *CloudMigrationServiceApi) EXPECT() *CloudMigrationServiceApi_Expecter {
	return &CloudMigrationServiceApi_Expecter{mock: &_m.Mock}
}

// CreateLinkToken provides a mock function with given fields: ctx, orgId, targetOrgRequest
func (_m *CloudMigrationServiceApi) CreateLinkToken(ctx context.Context, orgId string, targetOrgRequest *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest {
	ret := _m.Called(ctx, orgId, targetOrgRequest)

	if len(ret) == 0 {
		panic("no return value specified for CreateLinkToken")
	}

	var r0 admin.CreateLinkTokenApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest); ok {
		r0 = rf(ctx, orgId, targetOrgRequest)
	} else {
		r0 = ret.Get(0).(admin.CreateLinkTokenApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CreateLinkToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkToken'
type CloudMigrationServiceApi_CreateLinkToken_Call struct {
	*mock.Call
}

// CreateLinkToken is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - targetOrgRequest *admin.TargetOrgRequest
func (_e *CloudMigrationServiceApi_Expecter) CreateLinkToken(ctx interface{}, orgId interface{}, targetOrgRequest interface{}) *CloudMigrationServiceApi_CreateLinkToken_Call {
	return &CloudMigrationServiceApi_CreateLinkToken_Call{Call: _e.mock.On("CreateLinkToken", ctx, orgId, targetOrgRequest)}
}

func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) Run(run func(ctx context.Context, orgId string, targetOrgRequest *admin.TargetOrgRequest)) *CloudMigrationServiceApi_CreateLinkToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.TargetOrgRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) Return(_a0 admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkToken_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkToken_Call) RunAndReturn(run func(context.Context, string, *admin.TargetOrgRequest) admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkToken_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLinkTokenExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) CreateLinkTokenExecute(r admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreateLinkTokenExecute")
	}

	var r0 *admin.TargetOrg
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreateLinkTokenApiRequest) *admin.TargetOrg); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TargetOrg)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreateLinkTokenApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreateLinkTokenApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_CreateLinkTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkTokenExecute'
type CloudMigrationServiceApi_CreateLinkTokenExecute_Call struct {
	*mock.Call
}

// CreateLinkTokenExecute is a helper method to define mock.On call
//   - r admin.CreateLinkTokenApiRequest
func (_e *CloudMigrationServiceApi_Expecter) CreateLinkTokenExecute(r interface{}) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call {
	return &CloudMigrationServiceApi_CreateLinkTokenExecute_Call{Call: _e.mock.On("CreateLinkTokenExecute", r)}
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) Run(run func(r admin.CreateLinkTokenApiRequest)) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreateLinkTokenApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) Return(_a0 *admin.TargetOrg, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenExecute_Call) RunAndReturn(run func(admin.CreateLinkTokenApiRequest) (*admin.TargetOrg, *http.Response, error)) *CloudMigrationServiceApi_CreateLinkTokenExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLinkTokenWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) CreateLinkTokenWithParams(ctx context.Context, args *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for CreateLinkTokenWithParams")
	}

	var r0 admin.CreateLinkTokenApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreateLinkTokenApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CreateLinkTokenWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLinkTokenWithParams'
type CloudMigrationServiceApi_CreateLinkTokenWithParams_Call struct {
	*mock.Call
}

// CreateLinkTokenWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateLinkTokenApiParams
func (_e *CloudMigrationServiceApi_Expecter) CreateLinkTokenWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call {
	return &CloudMigrationServiceApi_CreateLinkTokenWithParams_Call{Call: _e.mock.On("CreateLinkTokenWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateLinkTokenApiParams)) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreateLinkTokenApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) Return(_a0 admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateLinkTokenApiParams) admin.CreateLinkTokenApiRequest) *CloudMigrationServiceApi_CreateLinkTokenWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePushMigration provides a mock function with given fields: ctx, groupId, liveMigrationRequest
func (_m *CloudMigrationServiceApi) CreatePushMigration(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest {
	ret := _m.Called(ctx, groupId, liveMigrationRequest)

	if len(ret) == 0 {
		panic("no return value specified for CreatePushMigration")
	}

	var r0 admin.CreatePushMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest); ok {
		r0 = rf(ctx, groupId, liveMigrationRequest)
	} else {
		r0 = ret.Get(0).(admin.CreatePushMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CreatePushMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigration'
type CloudMigrationServiceApi_CreatePushMigration_Call struct {
	*mock.Call
}

// CreatePushMigration is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - liveMigrationRequest *admin.LiveMigrationRequest
func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigration(ctx interface{}, groupId interface{}, liveMigrationRequest interface{}) *CloudMigrationServiceApi_CreatePushMigration_Call {
	return &CloudMigrationServiceApi_CreatePushMigration_Call{Call: _e.mock.On("CreatePushMigration", ctx, groupId, liveMigrationRequest)}
}

func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest)) *CloudMigrationServiceApi_CreatePushMigration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.LiveMigrationRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) Return(_a0 admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigration_Call) RunAndReturn(run func(context.Context, string, *admin.LiveMigrationRequest) admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigration_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePushMigrationExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) CreatePushMigrationExecute(r admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreatePushMigrationExecute")
	}

	var r0 *admin.LiveMigrationResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreatePushMigrationApiRequest) *admin.LiveMigrationResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LiveMigrationResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreatePushMigrationApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreatePushMigrationApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_CreatePushMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigrationExecute'
type CloudMigrationServiceApi_CreatePushMigrationExecute_Call struct {
	*mock.Call
}

// CreatePushMigrationExecute is a helper method to define mock.On call
//   - r admin.CreatePushMigrationApiRequest
func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigrationExecute(r interface{}) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call {
	return &CloudMigrationServiceApi_CreatePushMigrationExecute_Call{Call: _e.mock.On("CreatePushMigrationExecute", r)}
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) Run(run func(r admin.CreatePushMigrationApiRequest)) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreatePushMigrationApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) Return(_a0 *admin.LiveMigrationResponse, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationExecute_Call) RunAndReturn(run func(admin.CreatePushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)) *CloudMigrationServiceApi_CreatePushMigrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePushMigrationWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) CreatePushMigrationWithParams(ctx context.Context, args *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for CreatePushMigrationWithParams")
	}

	var r0 admin.CreatePushMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreatePushMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CreatePushMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePushMigrationWithParams'
type CloudMigrationServiceApi_CreatePushMigrationWithParams_Call struct {
	*mock.Call
}

// CreatePushMigrationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreatePushMigrationApiParams
func (_e *CloudMigrationServiceApi_Expecter) CreatePushMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call {
	return &CloudMigrationServiceApi_CreatePushMigrationWithParams_Call{Call: _e.mock.On("CreatePushMigrationWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.CreatePushMigrationApiParams)) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreatePushMigrationApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) Return(_a0 admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePushMigrationApiParams) admin.CreatePushMigrationApiRequest) *CloudMigrationServiceApi_CreatePushMigrationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CutoverMigration provides a mock function with given fields: ctx, groupId, liveMigrationId
func (_m *CloudMigrationServiceApi) CutoverMigration(ctx context.Context, groupId string, liveMigrationId string) admin.CutoverMigrationApiRequest {
	ret := _m.Called(ctx, groupId, liveMigrationId)

	if len(ret) == 0 {
		panic("no return value specified for CutoverMigration")
	}

	var r0 admin.CutoverMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.CutoverMigrationApiRequest); ok {
		r0 = rf(ctx, groupId, liveMigrationId)
	} else {
		r0 = ret.Get(0).(admin.CutoverMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CutoverMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigration'
type CloudMigrationServiceApi_CutoverMigration_Call struct {
	*mock.Call
}

// CutoverMigration is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - liveMigrationId string
func (_e *CloudMigrationServiceApi_Expecter) CutoverMigration(ctx interface{}, groupId interface{}, liveMigrationId interface{}) *CloudMigrationServiceApi_CutoverMigration_Call {
	return &CloudMigrationServiceApi_CutoverMigration_Call{Call: _e.mock.On("CutoverMigration", ctx, groupId, liveMigrationId)}
}

func (_c *CloudMigrationServiceApi_CutoverMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationId string)) *CloudMigrationServiceApi_CutoverMigration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigration_Call) Return(_a0 admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigration_Call) RunAndReturn(run func(context.Context, string, string) admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigration_Call {
	_c.Call.Return(run)
	return _c
}

// CutoverMigrationExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) CutoverMigrationExecute(r admin.CutoverMigrationApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CutoverMigrationExecute")
	}

	var r0 *http.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(admin.CutoverMigrationApiRequest) (*http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CutoverMigrationApiRequest) *http.Response); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CutoverMigrationApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CloudMigrationServiceApi_CutoverMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigrationExecute'
type CloudMigrationServiceApi_CutoverMigrationExecute_Call struct {
	*mock.Call
}

// CutoverMigrationExecute is a helper method to define mock.On call
//   - r admin.CutoverMigrationApiRequest
func (_e *CloudMigrationServiceApi_Expecter) CutoverMigrationExecute(r interface{}) *CloudMigrationServiceApi_CutoverMigrationExecute_Call {
	return &CloudMigrationServiceApi_CutoverMigrationExecute_Call{Call: _e.mock.On("CutoverMigrationExecute", r)}
}

func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) Run(run func(r admin.CutoverMigrationApiRequest)) *CloudMigrationServiceApi_CutoverMigrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CutoverMigrationApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) Return(_a0 *http.Response, _a1 error) *CloudMigrationServiceApi_CutoverMigrationExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigrationExecute_Call) RunAndReturn(run func(admin.CutoverMigrationApiRequest) (*http.Response, error)) *CloudMigrationServiceApi_CutoverMigrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CutoverMigrationWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) CutoverMigrationWithParams(ctx context.Context, args *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for CutoverMigrationWithParams")
	}

	var r0 admin.CutoverMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CutoverMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_CutoverMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CutoverMigrationWithParams'
type CloudMigrationServiceApi_CutoverMigrationWithParams_Call struct {
	*mock.Call
}

// CutoverMigrationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CutoverMigrationApiParams
func (_e *CloudMigrationServiceApi_Expecter) CutoverMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call {
	return &CloudMigrationServiceApi_CutoverMigrationWithParams_Call{Call: _e.mock.On("CutoverMigrationWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.CutoverMigrationApiParams)) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CutoverMigrationApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) Return(_a0 admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_CutoverMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.CutoverMigrationApiParams) admin.CutoverMigrationApiRequest) *CloudMigrationServiceApi_CutoverMigrationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLinkToken provides a mock function with given fields: ctx, orgId
func (_m *CloudMigrationServiceApi) DeleteLinkToken(ctx context.Context, orgId string) admin.DeleteLinkTokenApiRequest {
	ret := _m.Called(ctx, orgId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLinkToken")
	}

	var r0 admin.DeleteLinkTokenApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.DeleteLinkTokenApiRequest); ok {
		r0 = rf(ctx, orgId)
	} else {
		r0 = ret.Get(0).(admin.DeleteLinkTokenApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_DeleteLinkToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkToken'
type CloudMigrationServiceApi_DeleteLinkToken_Call struct {
	*mock.Call
}

// DeleteLinkToken is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkToken(ctx interface{}, orgId interface{}) *CloudMigrationServiceApi_DeleteLinkToken_Call {
	return &CloudMigrationServiceApi_DeleteLinkToken_Call{Call: _e.mock.On("DeleteLinkToken", ctx, orgId)}
}

func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) Run(run func(ctx context.Context, orgId string)) *CloudMigrationServiceApi_DeleteLinkToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) Return(_a0 admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkToken_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkToken_Call) RunAndReturn(run func(context.Context, string) admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLinkTokenExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) DeleteLinkTokenExecute(r admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLinkTokenExecute")
	}

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteLinkTokenApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DeleteLinkTokenApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DeleteLinkTokenApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_DeleteLinkTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkTokenExecute'
type CloudMigrationServiceApi_DeleteLinkTokenExecute_Call struct {
	*mock.Call
}

// DeleteLinkTokenExecute is a helper method to define mock.On call
//   - r admin.DeleteLinkTokenApiRequest
func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkTokenExecute(r interface{}) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call {
	return &CloudMigrationServiceApi_DeleteLinkTokenExecute_Call{Call: _e.mock.On("DeleteLinkTokenExecute", r)}
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) Run(run func(r admin.DeleteLinkTokenApiRequest)) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DeleteLinkTokenApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call) RunAndReturn(run func(admin.DeleteLinkTokenApiRequest) (map[string]interface{}, *http.Response, error)) *CloudMigrationServiceApi_DeleteLinkTokenExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLinkTokenWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) DeleteLinkTokenWithParams(ctx context.Context, args *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for DeleteLinkTokenWithParams")
	}

	var r0 admin.DeleteLinkTokenApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DeleteLinkTokenApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteLinkTokenWithParams'
type CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call struct {
	*mock.Call
}

// DeleteLinkTokenWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteLinkTokenApiParams
func (_e *CloudMigrationServiceApi_Expecter) DeleteLinkTokenWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call {
	return &CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call{Call: _e.mock.On("DeleteLinkTokenWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteLinkTokenApiParams)) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DeleteLinkTokenApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) Return(_a0 admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteLinkTokenApiParams) admin.DeleteLinkTokenApiRequest) *CloudMigrationServiceApi_DeleteLinkTokenWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetPushMigration provides a mock function with given fields: ctx, groupId, liveMigrationId
func (_m *CloudMigrationServiceApi) GetPushMigration(ctx context.Context, groupId string, liveMigrationId string) admin.GetPushMigrationApiRequest {
	ret := _m.Called(ctx, groupId, liveMigrationId)

	if len(ret) == 0 {
		panic("no return value specified for GetPushMigration")
	}

	var r0 admin.GetPushMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetPushMigrationApiRequest); ok {
		r0 = rf(ctx, groupId, liveMigrationId)
	} else {
		r0 = ret.Get(0).(admin.GetPushMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_GetPushMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigration'
type CloudMigrationServiceApi_GetPushMigration_Call struct {
	*mock.Call
}

// GetPushMigration is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - liveMigrationId string
func (_e *CloudMigrationServiceApi_Expecter) GetPushMigration(ctx interface{}, groupId interface{}, liveMigrationId interface{}) *CloudMigrationServiceApi_GetPushMigration_Call {
	return &CloudMigrationServiceApi_GetPushMigration_Call{Call: _e.mock.On("GetPushMigration", ctx, groupId, liveMigrationId)}
}

func (_c *CloudMigrationServiceApi_GetPushMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationId string)) *CloudMigrationServiceApi_GetPushMigration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigration_Call) Return(_a0 admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigration_Call) RunAndReturn(run func(context.Context, string, string) admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigration_Call {
	_c.Call.Return(run)
	return _c
}

// GetPushMigrationExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) GetPushMigrationExecute(r admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for GetPushMigrationExecute")
	}

	var r0 *admin.LiveMigrationResponse
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetPushMigrationApiRequest) *admin.LiveMigrationResponse); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LiveMigrationResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetPushMigrationApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetPushMigrationApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_GetPushMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigrationExecute'
type CloudMigrationServiceApi_GetPushMigrationExecute_Call struct {
	*mock.Call
}

// GetPushMigrationExecute is a helper method to define mock.On call
//   - r admin.GetPushMigrationApiRequest
func (_e *CloudMigrationServiceApi_Expecter) GetPushMigrationExecute(r interface{}) *CloudMigrationServiceApi_GetPushMigrationExecute_Call {
	return &CloudMigrationServiceApi_GetPushMigrationExecute_Call{Call: _e.mock.On("GetPushMigrationExecute", r)}
}

func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) Run(run func(r admin.GetPushMigrationApiRequest)) *CloudMigrationServiceApi_GetPushMigrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetPushMigrationApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) Return(_a0 *admin.LiveMigrationResponse, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_GetPushMigrationExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigrationExecute_Call) RunAndReturn(run func(admin.GetPushMigrationApiRequest) (*admin.LiveMigrationResponse, *http.Response, error)) *CloudMigrationServiceApi_GetPushMigrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetPushMigrationWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) GetPushMigrationWithParams(ctx context.Context, args *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for GetPushMigrationWithParams")
	}

	var r0 admin.GetPushMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetPushMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_GetPushMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPushMigrationWithParams'
type CloudMigrationServiceApi_GetPushMigrationWithParams_Call struct {
	*mock.Call
}

// GetPushMigrationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetPushMigrationApiParams
func (_e *CloudMigrationServiceApi_Expecter) GetPushMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call {
	return &CloudMigrationServiceApi_GetPushMigrationWithParams_Call{Call: _e.mock.On("GetPushMigrationWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.GetPushMigrationApiParams)) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetPushMigrationApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) Return(_a0 admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_GetPushMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPushMigrationApiParams) admin.GetPushMigrationApiRequest) *CloudMigrationServiceApi_GetPushMigrationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetValidationStatus provides a mock function with given fields: ctx, groupId, validationId
func (_m *CloudMigrationServiceApi) GetValidationStatus(ctx context.Context, groupId string, validationId string) admin.GetValidationStatusApiRequest {
	ret := _m.Called(ctx, groupId, validationId)

	if len(ret) == 0 {
		panic("no return value specified for GetValidationStatus")
	}

	var r0 admin.GetValidationStatusApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetValidationStatusApiRequest); ok {
		r0 = rf(ctx, groupId, validationId)
	} else {
		r0 = ret.Get(0).(admin.GetValidationStatusApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_GetValidationStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatus'
type CloudMigrationServiceApi_GetValidationStatus_Call struct {
	*mock.Call
}

// GetValidationStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - validationId string
func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatus(ctx interface{}, groupId interface{}, validationId interface{}) *CloudMigrationServiceApi_GetValidationStatus_Call {
	return &CloudMigrationServiceApi_GetValidationStatus_Call{Call: _e.mock.On("GetValidationStatus", ctx, groupId, validationId)}
}

func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) Run(run func(ctx context.Context, groupId string, validationId string)) *CloudMigrationServiceApi_GetValidationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) Return(_a0 admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatus_Call) RunAndReturn(run func(context.Context, string, string) admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetValidationStatusExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) GetValidationStatusExecute(r admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for GetValidationStatusExecute")
	}

	var r0 *admin.LiveImportValidation
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetValidationStatusApiRequest) *admin.LiveImportValidation); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LiveImportValidation)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetValidationStatusApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetValidationStatusApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_GetValidationStatusExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatusExecute'
type CloudMigrationServiceApi_GetValidationStatusExecute_Call struct {
	*mock.Call
}

// GetValidationStatusExecute is a helper method to define mock.On call
//   - r admin.GetValidationStatusApiRequest
func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatusExecute(r interface{}) *CloudMigrationServiceApi_GetValidationStatusExecute_Call {
	return &CloudMigrationServiceApi_GetValidationStatusExecute_Call{Call: _e.mock.On("GetValidationStatusExecute", r)}
}

func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) Run(run func(r admin.GetValidationStatusApiRequest)) *CloudMigrationServiceApi_GetValidationStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetValidationStatusApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) Return(_a0 *admin.LiveImportValidation, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_GetValidationStatusExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatusExecute_Call) RunAndReturn(run func(admin.GetValidationStatusApiRequest) (*admin.LiveImportValidation, *http.Response, error)) *CloudMigrationServiceApi_GetValidationStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetValidationStatusWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) GetValidationStatusWithParams(ctx context.Context, args *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for GetValidationStatusWithParams")
	}

	var r0 admin.GetValidationStatusApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetValidationStatusApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_GetValidationStatusWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidationStatusWithParams'
type CloudMigrationServiceApi_GetValidationStatusWithParams_Call struct {
	*mock.Call
}

// GetValidationStatusWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetValidationStatusApiParams
func (_e *CloudMigrationServiceApi_Expecter) GetValidationStatusWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call {
	return &CloudMigrationServiceApi_GetValidationStatusWithParams_Call{Call: _e.mock.On("GetValidationStatusWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) Run(run func(ctx context.Context, args *admin.GetValidationStatusApiParams)) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetValidationStatusApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) Return(_a0 admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_GetValidationStatusWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetValidationStatusApiParams) admin.GetValidationStatusApiRequest) *CloudMigrationServiceApi_GetValidationStatusWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListSourceProjects provides a mock function with given fields: ctx, orgId
func (_m *CloudMigrationServiceApi) ListSourceProjects(ctx context.Context, orgId string) admin.ListSourceProjectsApiRequest {
	ret := _m.Called(ctx, orgId)

	if len(ret) == 0 {
		panic("no return value specified for ListSourceProjects")
	}

	var r0 admin.ListSourceProjectsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListSourceProjectsApiRequest); ok {
		r0 = rf(ctx, orgId)
	} else {
		r0 = ret.Get(0).(admin.ListSourceProjectsApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_ListSourceProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjects'
type CloudMigrationServiceApi_ListSourceProjects_Call struct {
	*mock.Call
}

// ListSourceProjects is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjects(ctx interface{}, orgId interface{}) *CloudMigrationServiceApi_ListSourceProjects_Call {
	return &CloudMigrationServiceApi_ListSourceProjects_Call{Call: _e.mock.On("ListSourceProjects", ctx, orgId)}
}

func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) Run(run func(ctx context.Context, orgId string)) *CloudMigrationServiceApi_ListSourceProjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) Return(_a0 admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjects_Call) RunAndReturn(run func(context.Context, string) admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjects_Call {
	_c.Call.Return(run)
	return _c
}

// ListSourceProjectsExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) ListSourceProjectsExecute(r admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListSourceProjectsExecute")
	}

	var r0 []admin.LiveImportAvailableProject
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListSourceProjectsApiRequest) []admin.LiveImportAvailableProject); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]admin.LiveImportAvailableProject)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListSourceProjectsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListSourceProjectsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_ListSourceProjectsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjectsExecute'
type CloudMigrationServiceApi_ListSourceProjectsExecute_Call struct {
	*mock.Call
}

// ListSourceProjectsExecute is a helper method to define mock.On call
//   - r admin.ListSourceProjectsApiRequest
func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjectsExecute(r interface{}) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call {
	return &CloudMigrationServiceApi_ListSourceProjectsExecute_Call{Call: _e.mock.On("ListSourceProjectsExecute", r)}
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) Run(run func(r admin.ListSourceProjectsApiRequest)) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListSourceProjectsApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) Return(_a0 []admin.LiveImportAvailableProject, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsExecute_Call) RunAndReturn(run func(admin.ListSourceProjectsApiRequest) ([]admin.LiveImportAvailableProject, *http.Response, error)) *CloudMigrationServiceApi_ListSourceProjectsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListSourceProjectsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) ListSourceProjectsWithParams(ctx context.Context, args *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ListSourceProjectsWithParams")
	}

	var r0 admin.ListSourceProjectsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListSourceProjectsApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_ListSourceProjectsWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSourceProjectsWithParams'
type CloudMigrationServiceApi_ListSourceProjectsWithParams_Call struct {
	*mock.Call
}

// ListSourceProjectsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListSourceProjectsApiParams
func (_e *CloudMigrationServiceApi_Expecter) ListSourceProjectsWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call {
	return &CloudMigrationServiceApi_ListSourceProjectsWithParams_Call{Call: _e.mock.On("ListSourceProjectsWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListSourceProjectsApiParams)) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListSourceProjectsApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) Return(_a0 admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListSourceProjectsApiParams) admin.ListSourceProjectsApiRequest) *CloudMigrationServiceApi_ListSourceProjectsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateMigration provides a mock function with given fields: ctx, groupId, liveMigrationRequest
func (_m *CloudMigrationServiceApi) ValidateMigration(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest {
	ret := _m.Called(ctx, groupId, liveMigrationRequest)

	if len(ret) == 0 {
		panic("no return value specified for ValidateMigration")
	}

	var r0 admin.ValidateMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest); ok {
		r0 = rf(ctx, groupId, liveMigrationRequest)
	} else {
		r0 = ret.Get(0).(admin.ValidateMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_ValidateMigration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigration'
type CloudMigrationServiceApi_ValidateMigration_Call struct {
	*mock.Call
}

// ValidateMigration is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - liveMigrationRequest *admin.LiveMigrationRequest
func (_e *CloudMigrationServiceApi_Expecter) ValidateMigration(ctx interface{}, groupId interface{}, liveMigrationRequest interface{}) *CloudMigrationServiceApi_ValidateMigration_Call {
	return &CloudMigrationServiceApi_ValidateMigration_Call{Call: _e.mock.On("ValidateMigration", ctx, groupId, liveMigrationRequest)}
}

func (_c *CloudMigrationServiceApi_ValidateMigration_Call) Run(run func(ctx context.Context, groupId string, liveMigrationRequest *admin.LiveMigrationRequest)) *CloudMigrationServiceApi_ValidateMigration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.LiveMigrationRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigration_Call) Return(_a0 admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigration_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigration_Call) RunAndReturn(run func(context.Context, string, *admin.LiveMigrationRequest) admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigration_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateMigrationExecute provides a mock function with given fields: r
func (_m *CloudMigrationServiceApi) ValidateMigrationExecute(r admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error) {
	ret := _m.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ValidateMigrationExecute")
	}

	var r0 *admin.LiveImportValidation
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ValidateMigrationApiRequest) *admin.LiveImportValidation); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LiveImportValidation)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ValidateMigrationApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ValidateMigrationApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// CloudMigrationServiceApi_ValidateMigrationExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigrationExecute'
type CloudMigrationServiceApi_ValidateMigrationExecute_Call struct {
	*mock.Call
}

// ValidateMigrationExecute is a helper method to define mock.On call
//   - r admin.ValidateMigrationApiRequest
func (_e *CloudMigrationServiceApi_Expecter) ValidateMigrationExecute(r interface{}) *CloudMigrationServiceApi_ValidateMigrationExecute_Call {
	return &CloudMigrationServiceApi_ValidateMigrationExecute_Call{Call: _e.mock.On("ValidateMigrationExecute", r)}
}

func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) Run(run func(r admin.ValidateMigrationApiRequest)) *CloudMigrationServiceApi_ValidateMigrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ValidateMigrationApiRequest))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) Return(_a0 *admin.LiveImportValidation, _a1 *http.Response, _a2 error) *CloudMigrationServiceApi_ValidateMigrationExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigrationExecute_Call) RunAndReturn(run func(admin.ValidateMigrationApiRequest) (*admin.LiveImportValidation, *http.Response, error)) *CloudMigrationServiceApi_ValidateMigrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateMigrationWithParams provides a mock function with given fields: ctx, args
func (_m *CloudMigrationServiceApi) ValidateMigrationWithParams(ctx context.Context, args *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest {
	ret := _m.Called(ctx, args)

	if len(ret) == 0 {
		panic("no return value specified for ValidateMigrationWithParams")
	}

	var r0 admin.ValidateMigrationApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ValidateMigrationApiRequest)
	}

	return r0
}

// CloudMigrationServiceApi_ValidateMigrationWithParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateMigrationWithParams'
type CloudMigrationServiceApi_ValidateMigrationWithParams_Call struct {
	*mock.Call
}

// ValidateMigrationWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ValidateMigrationApiParams
func (_e *CloudMigrationServiceApi_Expecter) ValidateMigrationWithParams(ctx interface{}, args interface{}) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call {
	return &CloudMigrationServiceApi_ValidateMigrationWithParams_Call{Call: _e.mock.On("ValidateMigrationWithParams", ctx, args)}
}

func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) Run(run func(ctx context.Context, args *admin.ValidateMigrationApiParams)) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ValidateMigrationApiParams))
	})
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) Return(_a0 admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudMigrationServiceApi_ValidateMigrationWithParams_Call) RunAndReturn(run func(context.Context, *admin.ValidateMigrationApiParams) admin.ValidateMigrationApiRequest) *CloudMigrationServiceApi_ValidateMigrationWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewCloudMigrationServiceApi creates a new instance of CloudMigrationServiceApi. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewCloudMigrationServiceApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *CloudMigrationServiceApi {
	mock := &CloudMigrationServiceApi{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}