legacy_backup_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"
)

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

type LegacyBackupApi_Expecter struct {
	mock *mock.Mock
}

func (_m *LegacyBackupApi) EXPECT() *LegacyBackupApi_Expecter {
	return &LegacyBackupApi_Expecter{mock: &_m.Mock}
}

// DeleteLegacySnapshot provides a mock function with given fields: ctx, groupId, clusterName, snapshotId
func (_m *LegacyBackupApi) DeleteLegacySnapshot(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.DeleteLegacySnapshotApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, snapshotId)

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

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

	return r0
}

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

// DeleteLegacySnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - snapshotId string
func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *LegacyBackupApi_DeleteLegacySnapshot_Call {
	return &LegacyBackupApi_DeleteLegacySnapshot_Call{Call: _e.mock.On("DeleteLegacySnapshot", ctx, groupId, clusterName, snapshotId)}
}

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

func (_c *LegacyBackupApi_DeleteLegacySnapshot_Call) Return(_a0 admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshot_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteLegacySnapshotApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteLegacySnapshotApiRequest) 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.DeleteLegacySnapshotApiRequest) *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.DeleteLegacySnapshotApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeleteLegacySnapshotExecute is a helper method to define mock.On call
//   - r admin.DeleteLegacySnapshotApiRequest
func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshotExecute(r interface{}) *LegacyBackupApi_DeleteLegacySnapshotExecute_Call {
	return &LegacyBackupApi_DeleteLegacySnapshotExecute_Call{Call: _e.mock.On("DeleteLegacySnapshotExecute", r)}
}

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

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

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

// DeleteLegacySnapshotWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) DeleteLegacySnapshotWithParams(ctx context.Context, args *admin.DeleteLegacySnapshotApiParams) admin.DeleteLegacySnapshotApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteLegacySnapshotWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteLegacySnapshotApiParams
func (_e *LegacyBackupApi_Expecter) DeleteLegacySnapshotWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call {
	return &LegacyBackupApi_DeleteLegacySnapshotWithParams_Call{Call: _e.mock.On("DeleteLegacySnapshotWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call) Return(_a0 admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteLegacySnapshotApiParams) admin.DeleteLegacySnapshotApiRequest) *LegacyBackupApi_DeleteLegacySnapshotWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacyBackupCheckpoint provides a mock function with given fields: ctx, groupId, checkpointId, clusterName
func (_m *LegacyBackupApi) GetLegacyBackupCheckpoint(ctx context.Context, groupId string, checkpointId string, clusterName string) admin.GetLegacyBackupCheckpointApiRequest {
	ret := _m.Called(ctx, groupId, checkpointId, clusterName)

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

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

	return r0
}

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

// GetLegacyBackupCheckpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - checkpointId string
//   - clusterName string
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpoint(ctx interface{}, groupId interface{}, checkpointId interface{}, clusterName interface{}) *LegacyBackupApi_GetLegacyBackupCheckpoint_Call {
	return &LegacyBackupApi_GetLegacyBackupCheckpoint_Call{Call: _e.mock.On("GetLegacyBackupCheckpoint", ctx, groupId, checkpointId, clusterName)}
}

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

func (_c *LegacyBackupApi_GetLegacyBackupCheckpoint_Call) Return(_a0 admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetLegacyBackupCheckpointExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) GetLegacyBackupCheckpointExecute(r admin.GetLegacyBackupCheckpointApiRequest) (*admin.ApiAtlasCheckpoint, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetLegacyBackupCheckpointApiRequest) *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.GetLegacyBackupCheckpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetLegacyBackupCheckpointExecute is a helper method to define mock.On call
//   - r admin.GetLegacyBackupCheckpointApiRequest
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpointExecute(r interface{}) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call {
	return &LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call{Call: _e.mock.On("GetLegacyBackupCheckpointExecute", r)}
}

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

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

func (_c *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call) RunAndReturn(run func(admin.GetLegacyBackupCheckpointApiRequest) (*admin.ApiAtlasCheckpoint, *http.Response, error)) *LegacyBackupApi_GetLegacyBackupCheckpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacyBackupCheckpointWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) GetLegacyBackupCheckpointWithParams(ctx context.Context, args *admin.GetLegacyBackupCheckpointApiParams) admin.GetLegacyBackupCheckpointApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetLegacyBackupCheckpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetLegacyBackupCheckpointApiParams
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupCheckpointWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call {
	return &LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call{Call: _e.mock.On("GetLegacyBackupCheckpointWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call) Return(_a0 admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacyBackupCheckpointApiParams) admin.GetLegacyBackupCheckpointApiRequest) *LegacyBackupApi_GetLegacyBackupCheckpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacyBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, jobId
func (_m *LegacyBackupApi) GetLegacyBackupRestoreJob(ctx context.Context, groupId string, clusterName string, jobId string) admin.GetLegacyBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, jobId)

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

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

	return r0
}

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

// GetLegacyBackupRestoreJob is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - jobId string
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, jobId interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJob_Call {
	return &LegacyBackupApi_GetLegacyBackupRestoreJob_Call{Call: _e.mock.On("GetLegacyBackupRestoreJob", ctx, groupId, clusterName, jobId)}
}

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

func (_c *LegacyBackupApi_GetLegacyBackupRestoreJob_Call) Return(_a0 admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetLegacyBackupRestoreJobExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) GetLegacyBackupRestoreJobExecute(r admin.GetLegacyBackupRestoreJobApiRequest) (*admin.BackupRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetLegacyBackupRestoreJobApiRequest) *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.GetLegacyBackupRestoreJobApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetLegacyBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.GetLegacyBackupRestoreJobApiRequest
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJobExecute(r interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call {
	return &LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call{Call: _e.mock.On("GetLegacyBackupRestoreJobExecute", r)}
}

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

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

func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetLegacyBackupRestoreJobApiRequest) (*admin.BackupRestoreJob, *http.Response, error)) *LegacyBackupApi_GetLegacyBackupRestoreJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacyBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) GetLegacyBackupRestoreJobWithParams(ctx context.Context, args *admin.GetLegacyBackupRestoreJobApiParams) admin.GetLegacyBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetLegacyBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetLegacyBackupRestoreJobApiParams
func (_e *LegacyBackupApi_Expecter) GetLegacyBackupRestoreJobWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call {
	return &LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetLegacyBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call) Return(_a0 admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacyBackupRestoreJobApiParams) admin.GetLegacyBackupRestoreJobApiRequest) *LegacyBackupApi_GetLegacyBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacySnapshot provides a mock function with given fields: ctx, groupId, clusterName, snapshotId
func (_m *LegacyBackupApi) GetLegacySnapshot(ctx context.Context, groupId string, clusterName string, snapshotId string) admin.GetLegacySnapshotApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, snapshotId)

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

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

	return r0
}

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

// GetLegacySnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - snapshotId string
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}) *LegacyBackupApi_GetLegacySnapshot_Call {
	return &LegacyBackupApi_GetLegacySnapshot_Call{Call: _e.mock.On("GetLegacySnapshot", ctx, groupId, clusterName, snapshotId)}
}

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

func (_c *LegacyBackupApi_GetLegacySnapshot_Call) Return(_a0 admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshot_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetLegacySnapshotExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) GetLegacySnapshotExecute(r admin.GetLegacySnapshotApiRequest) (*admin.BackupSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetLegacySnapshotApiRequest) *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.GetLegacySnapshotApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetLegacySnapshotExecute is a helper method to define mock.On call
//   - r admin.GetLegacySnapshotApiRequest
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotExecute(r interface{}) *LegacyBackupApi_GetLegacySnapshotExecute_Call {
	return &LegacyBackupApi_GetLegacySnapshotExecute_Call{Call: _e.mock.On("GetLegacySnapshotExecute", r)}
}

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

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

func (_c *LegacyBackupApi_GetLegacySnapshotExecute_Call) RunAndReturn(run func(admin.GetLegacySnapshotApiRequest) (*admin.BackupSnapshot, *http.Response, error)) *LegacyBackupApi_GetLegacySnapshotExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacySnapshotSchedule provides a mock function with given fields: ctx, groupId, clusterName
func (_m *LegacyBackupApi) GetLegacySnapshotSchedule(ctx context.Context, groupId string, clusterName string) admin.GetLegacySnapshotScheduleApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

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

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

	return r0
}

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

// GetLegacySnapshotSchedule is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotSchedule(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_GetLegacySnapshotSchedule_Call {
	return &LegacyBackupApi_GetLegacySnapshotSchedule_Call{Call: _e.mock.On("GetLegacySnapshotSchedule", ctx, groupId, clusterName)}
}

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

func (_c *LegacyBackupApi_GetLegacySnapshotSchedule_Call) Return(_a0 admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotSchedule_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetLegacySnapshotScheduleExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) GetLegacySnapshotScheduleExecute(r admin.GetLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetLegacySnapshotScheduleApiRequest) *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.GetLegacySnapshotScheduleApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetLegacySnapshotScheduleExecute is a helper method to define mock.On call
//   - r admin.GetLegacySnapshotScheduleApiRequest
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotScheduleExecute(r interface{}) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call {
	return &LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call{Call: _e.mock.On("GetLegacySnapshotScheduleExecute", r)}
}

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

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

func (_c *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call) RunAndReturn(run func(admin.GetLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)) *LegacyBackupApi_GetLegacySnapshotScheduleExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacySnapshotScheduleWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) GetLegacySnapshotScheduleWithParams(ctx context.Context, args *admin.GetLegacySnapshotScheduleApiParams) admin.GetLegacySnapshotScheduleApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetLegacySnapshotScheduleWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetLegacySnapshotScheduleApiParams
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotScheduleWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call {
	return &LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call{Call: _e.mock.On("GetLegacySnapshotScheduleWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call) Return(_a0 admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacySnapshotScheduleApiParams) admin.GetLegacySnapshotScheduleApiRequest) *LegacyBackupApi_GetLegacySnapshotScheduleWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetLegacySnapshotWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) GetLegacySnapshotWithParams(ctx context.Context, args *admin.GetLegacySnapshotApiParams) admin.GetLegacySnapshotApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetLegacySnapshotWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetLegacySnapshotApiParams
func (_e *LegacyBackupApi_Expecter) GetLegacySnapshotWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_GetLegacySnapshotWithParams_Call {
	return &LegacyBackupApi_GetLegacySnapshotWithParams_Call{Call: _e.mock.On("GetLegacySnapshotWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_GetLegacySnapshotWithParams_Call) Return(_a0 admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshotWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_GetLegacySnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetLegacySnapshotApiParams) admin.GetLegacySnapshotApiRequest) *LegacyBackupApi_GetLegacySnapshotWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacyBackupCheckpoints provides a mock function with given fields: ctx, groupId, clusterName
func (_m *LegacyBackupApi) ListLegacyBackupCheckpoints(ctx context.Context, groupId string, clusterName string) admin.ListLegacyBackupCheckpointsApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

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

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

	return r0
}

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

// ListLegacyBackupCheckpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpoints(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call {
	return &LegacyBackupApi_ListLegacyBackupCheckpoints_Call{Call: _e.mock.On("ListLegacyBackupCheckpoints", ctx, groupId, clusterName)}
}

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

func (_c *LegacyBackupApi_ListLegacyBackupCheckpoints_Call) Return(_a0 admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpoints_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListLegacyBackupCheckpointsExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) ListLegacyBackupCheckpointsExecute(r admin.ListLegacyBackupCheckpointsApiRequest) (*admin.PaginatedApiAtlasCheckpoint, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ListLegacyBackupCheckpointsApiRequest) *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.ListLegacyBackupCheckpointsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListLegacyBackupCheckpointsExecute is a helper method to define mock.On call
//   - r admin.ListLegacyBackupCheckpointsApiRequest
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpointsExecute(r interface{}) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call {
	return &LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call{Call: _e.mock.On("ListLegacyBackupCheckpointsExecute", r)}
}

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

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

func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call) RunAndReturn(run func(admin.ListLegacyBackupCheckpointsApiRequest) (*admin.PaginatedApiAtlasCheckpoint, *http.Response, error)) *LegacyBackupApi_ListLegacyBackupCheckpointsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacyBackupCheckpointsWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) ListLegacyBackupCheckpointsWithParams(ctx context.Context, args *admin.ListLegacyBackupCheckpointsApiParams) admin.ListLegacyBackupCheckpointsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListLegacyBackupCheckpointsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListLegacyBackupCheckpointsApiParams
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupCheckpointsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call {
	return &LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call{Call: _e.mock.On("ListLegacyBackupCheckpointsWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call) Return(_a0 admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacyBackupCheckpointsApiParams) admin.ListLegacyBackupCheckpointsApiRequest) *LegacyBackupApi_ListLegacyBackupCheckpointsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacyBackupRestoreJobs provides a mock function with given fields: ctx, groupId, clusterName
func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobs(ctx context.Context, groupId string, clusterName string) admin.ListLegacyBackupRestoreJobsApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

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

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

	return r0
}

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

// ListLegacyBackupRestoreJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobs(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call {
	return &LegacyBackupApi_ListLegacyBackupRestoreJobs_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobs", ctx, groupId, clusterName)}
}

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

func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call) Return(_a0 admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListLegacyBackupRestoreJobsExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobsExecute(r admin.ListLegacyBackupRestoreJobsApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ListLegacyBackupRestoreJobsApiRequest) *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.ListLegacyBackupRestoreJobsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListLegacyBackupRestoreJobsExecute is a helper method to define mock.On call
//   - r admin.ListLegacyBackupRestoreJobsApiRequest
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobsExecute(r interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call {
	return &LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobsExecute", r)}
}

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

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

func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListLegacyBackupRestoreJobsApiRequest) (*admin.PaginatedRestoreJob, *http.Response, error)) *LegacyBackupApi_ListLegacyBackupRestoreJobsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacyBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) ListLegacyBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListLegacyBackupRestoreJobsApiParams) admin.ListLegacyBackupRestoreJobsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListLegacyBackupRestoreJobsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListLegacyBackupRestoreJobsApiParams
func (_e *LegacyBackupApi_Expecter) ListLegacyBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call {
	return &LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListLegacyBackupRestoreJobsWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacyBackupRestoreJobsApiParams) admin.ListLegacyBackupRestoreJobsApiRequest) *LegacyBackupApi_ListLegacyBackupRestoreJobsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacySnapshots provides a mock function with given fields: ctx, groupId, clusterName
func (_m *LegacyBackupApi) ListLegacySnapshots(ctx context.Context, groupId string, clusterName string) admin.ListLegacySnapshotsApiRequest {
	ret := _m.Called(ctx, groupId, clusterName)

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

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

	return r0
}

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

// ListLegacySnapshots is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
func (_e *LegacyBackupApi_Expecter) ListLegacySnapshots(ctx interface{}, groupId interface{}, clusterName interface{}) *LegacyBackupApi_ListLegacySnapshots_Call {
	return &LegacyBackupApi_ListLegacySnapshots_Call{Call: _e.mock.On("ListLegacySnapshots", ctx, groupId, clusterName)}
}

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

func (_c *LegacyBackupApi_ListLegacySnapshots_Call) Return(_a0 admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshots_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListLegacySnapshotsExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) ListLegacySnapshotsExecute(r admin.ListLegacySnapshotsApiRequest) (*admin.PaginatedSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ListLegacySnapshotsApiRequest) *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.ListLegacySnapshotsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListLegacySnapshotsExecute is a helper method to define mock.On call
//   - r admin.ListLegacySnapshotsApiRequest
func (_e *LegacyBackupApi_Expecter) ListLegacySnapshotsExecute(r interface{}) *LegacyBackupApi_ListLegacySnapshotsExecute_Call {
	return &LegacyBackupApi_ListLegacySnapshotsExecute_Call{Call: _e.mock.On("ListLegacySnapshotsExecute", r)}
}

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

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

func (_c *LegacyBackupApi_ListLegacySnapshotsExecute_Call) RunAndReturn(run func(admin.ListLegacySnapshotsApiRequest) (*admin.PaginatedSnapshot, *http.Response, error)) *LegacyBackupApi_ListLegacySnapshotsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListLegacySnapshotsWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) ListLegacySnapshotsWithParams(ctx context.Context, args *admin.ListLegacySnapshotsApiParams) admin.ListLegacySnapshotsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListLegacySnapshotsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListLegacySnapshotsApiParams
func (_e *LegacyBackupApi_Expecter) ListLegacySnapshotsWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call {
	return &LegacyBackupApi_ListLegacySnapshotsWithParams_Call{Call: _e.mock.On("ListLegacySnapshotsWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_ListLegacySnapshotsWithParams_Call) Return(_a0 admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_ListLegacySnapshotsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListLegacySnapshotsApiParams) admin.ListLegacySnapshotsApiRequest) *LegacyBackupApi_ListLegacySnapshotsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotRetention provides a mock function with given fields: ctx, groupId, clusterName, snapshotId, backupSnapshot
func (_m *LegacyBackupApi) UpdateLegacySnapshotRetention(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshot *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, snapshotId, backupSnapshot)

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

	var r0 admin.UpdateLegacySnapshotRetentionApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest); ok {
		r0 = rf(ctx, groupId, clusterName, snapshotId, backupSnapshot)
	} else {
		r0 = ret.Get(0).(admin.UpdateLegacySnapshotRetentionApiRequest)
	}

	return r0
}

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

// UpdateLegacySnapshotRetention is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - snapshotId string
//   - backupSnapshot *admin.BackupSnapshot
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetention(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}, backupSnapshot interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotRetention_Call{Call: _e.mock.On("UpdateLegacySnapshotRetention", ctx, groupId, clusterName, snapshotId, backupSnapshot)}
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshot *admin.BackupSnapshot)) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*admin.BackupSnapshot))
	})
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) Return(_a0 admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetention_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupSnapshot) admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetention_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotRetentionExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) UpdateLegacySnapshotRetentionExecute(r admin.UpdateLegacySnapshotRetentionApiRequest) (*admin.BackupSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.UpdateLegacySnapshotRetentionApiRequest) *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.UpdateLegacySnapshotRetentionApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// UpdateLegacySnapshotRetentionExecute is a helper method to define mock.On call
//   - r admin.UpdateLegacySnapshotRetentionApiRequest
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetentionExecute(r interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call{Call: _e.mock.On("UpdateLegacySnapshotRetentionExecute", r)}
}

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

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

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call) RunAndReturn(run func(admin.UpdateLegacySnapshotRetentionApiRequest) (*admin.BackupSnapshot, *http.Response, error)) *LegacyBackupApi_UpdateLegacySnapshotRetentionExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotRetentionWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) UpdateLegacySnapshotRetentionWithParams(ctx context.Context, args *admin.UpdateLegacySnapshotRetentionApiParams) admin.UpdateLegacySnapshotRetentionApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateLegacySnapshotRetentionWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateLegacySnapshotRetentionApiParams
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotRetentionWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call{Call: _e.mock.On("UpdateLegacySnapshotRetentionWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call) Return(_a0 admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateLegacySnapshotRetentionApiParams) admin.UpdateLegacySnapshotRetentionApiRequest) *LegacyBackupApi_UpdateLegacySnapshotRetentionWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotSchedule provides a mock function with given fields: ctx, groupId, clusterName, apiAtlasSnapshotSchedule
func (_m *LegacyBackupApi) UpdateLegacySnapshotSchedule(ctx context.Context, groupId string, clusterName string, apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, apiAtlasSnapshotSchedule)

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

	var r0 admin.UpdateLegacySnapshotScheduleApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest); ok {
		r0 = rf(ctx, groupId, clusterName, apiAtlasSnapshotSchedule)
	} else {
		r0 = ret.Get(0).(admin.UpdateLegacySnapshotScheduleApiRequest)
	}

	return r0
}

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

// UpdateLegacySnapshotSchedule is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotSchedule(ctx interface{}, groupId interface{}, clusterName interface{}, apiAtlasSnapshotSchedule interface{}) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotSchedule_Call{Call: _e.mock.On("UpdateLegacySnapshotSchedule", ctx, groupId, clusterName, apiAtlasSnapshotSchedule)}
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) Run(run func(ctx context.Context, groupId string, clusterName string, apiAtlasSnapshotSchedule *admin.ApiAtlasSnapshotSchedule)) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ApiAtlasSnapshotSchedule))
	})
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) Return(_a0 admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call) RunAndReturn(run func(context.Context, string, string, *admin.ApiAtlasSnapshotSchedule) admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotSchedule_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotScheduleExecute provides a mock function with given fields: r
func (_m *LegacyBackupApi) UpdateLegacySnapshotScheduleExecute(r admin.UpdateLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.UpdateLegacySnapshotScheduleApiRequest) *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.UpdateLegacySnapshotScheduleApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// UpdateLegacySnapshotScheduleExecute is a helper method to define mock.On call
//   - r admin.UpdateLegacySnapshotScheduleApiRequest
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotScheduleExecute(r interface{}) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call{Call: _e.mock.On("UpdateLegacySnapshotScheduleExecute", r)}
}

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

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

func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call) RunAndReturn(run func(admin.UpdateLegacySnapshotScheduleApiRequest) (*admin.ApiAtlasSnapshotSchedule, *http.Response, error)) *LegacyBackupApi_UpdateLegacySnapshotScheduleExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLegacySnapshotScheduleWithParams provides a mock function with given fields: ctx, args
func (_m *LegacyBackupApi) UpdateLegacySnapshotScheduleWithParams(ctx context.Context, args *admin.UpdateLegacySnapshotScheduleApiParams) admin.UpdateLegacySnapshotScheduleApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateLegacySnapshotScheduleWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateLegacySnapshotScheduleApiParams
func (_e *LegacyBackupApi_Expecter) UpdateLegacySnapshotScheduleWithParams(ctx interface{}, args interface{}) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call {
	return &LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call{Call: _e.mock.On("UpdateLegacySnapshotScheduleWithParams", ctx, args)}
}

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

func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call) Return(_a0 admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateLegacySnapshotScheduleApiParams) admin.UpdateLegacySnapshotScheduleApiRequest) *LegacyBackupApi_UpdateLegacySnapshotScheduleWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewLegacyBackupApi creates a new instance of LegacyBackupApi. 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 NewLegacyBackupApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *LegacyBackupApi {
	mock := &LegacyBackupApi{}
	mock.Mock.Test(t)

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

	return mock
}