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

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

type CloudBackupsApi_Expecter struct {
	mock *mock.Mock
}

func (_m *CloudBackupsApi) EXPECT() *CloudBackupsApi_Expecter {
	return &CloudBackupsApi_Expecter{mock: &_m.Mock}
}

// CancelBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId
func (_m *CloudBackupsApi) CancelBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.CancelBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, restoreJobId)

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_CancelBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_CancelBackupRestoreJob_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 *CloudBackupsApi_CancelBackupRestoreJob_Call) Return(_a0 admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// CancelBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.CancelBackupRestoreJobApiRequest
func (_e *CloudBackupsApi_Expecter) CancelBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CancelBackupRestoreJobExecute_Call {
	return &CloudBackupsApi_CancelBackupRestoreJobExecute_Call{Call: _e.mock.On("CancelBackupRestoreJobExecute", r)}
}

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

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

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

// CancelBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) CancelBackupRestoreJobWithParams(ctx context.Context, args *admin.CancelBackupRestoreJobApiParams) admin.CancelBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CancelBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CancelBackupRestoreJobApiParams
func (_e *CloudBackupsApi_Expecter) CancelBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call {
	return &CloudBackupsApi_CancelBackupRestoreJobWithParams_Call{Call: _e.mock.On("CancelBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call) Return(_a0 admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CancelBackupRestoreJobApiParams) admin.CancelBackupRestoreJobApiRequest) *CloudBackupsApi_CancelBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupExportJob provides a mock function with given fields: ctx, groupId, clusterName, diskBackupExportJobRequest
func (_m *CloudBackupsApi) CreateBackupExportJob(ctx context.Context, groupId string, clusterName string, diskBackupExportJobRequest *admin.DiskBackupExportJobRequest) admin.CreateBackupExportJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, diskBackupExportJobRequest)

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

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

	return r0
}

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

// CreateBackupExportJob is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - diskBackupExportJobRequest *admin.DiskBackupExportJobRequest
func (_e *CloudBackupsApi_Expecter) CreateBackupExportJob(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupExportJobRequest interface{}) *CloudBackupsApi_CreateBackupExportJob_Call {
	return &CloudBackupsApi_CreateBackupExportJob_Call{Call: _e.mock.On("CreateBackupExportJob", ctx, groupId, clusterName, diskBackupExportJobRequest)}
}

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

func (_c *CloudBackupsApi_CreateBackupExportJob_Call) Return(_a0 admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJob_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateBackupExportJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupExportJobRequest) admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJob_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupExportJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) CreateBackupExportJobExecute(r admin.CreateBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateBackupExportJobExecute is a helper method to define mock.On call
//   - r admin.CreateBackupExportJobApiRequest
func (_e *CloudBackupsApi_Expecter) CreateBackupExportJobExecute(r interface{}) *CloudBackupsApi_CreateBackupExportJobExecute_Call {
	return &CloudBackupsApi_CreateBackupExportJobExecute_Call{Call: _e.mock.On("CreateBackupExportJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_CreateBackupExportJobExecute_Call) RunAndReturn(run func(admin.CreateBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_CreateBackupExportJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupExportJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) CreateBackupExportJobWithParams(ctx context.Context, args *admin.CreateBackupExportJobApiParams) admin.CreateBackupExportJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateBackupExportJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateBackupExportJobApiParams
func (_e *CloudBackupsApi_Expecter) CreateBackupExportJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateBackupExportJobWithParams_Call {
	return &CloudBackupsApi_CreateBackupExportJobWithParams_Call{Call: _e.mock.On("CreateBackupExportJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_CreateBackupExportJobWithParams_Call) Return(_a0 admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateBackupExportJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateBackupExportJobApiParams) admin.CreateBackupExportJobApiRequest) *CloudBackupsApi_CreateBackupExportJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, diskBackupSnapshotRestoreJob
func (_m *CloudBackupsApi) CreateBackupRestoreJob(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotRestoreJob *admin.DiskBackupSnapshotRestoreJob) admin.CreateBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, diskBackupSnapshotRestoreJob)

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

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

	return r0
}

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

// CreateBackupRestoreJob is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - diskBackupSnapshotRestoreJob *admin.DiskBackupSnapshotRestoreJob
func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupSnapshotRestoreJob interface{}) *CloudBackupsApi_CreateBackupRestoreJob_Call {
	return &CloudBackupsApi_CreateBackupRestoreJob_Call{Call: _e.mock.On("CreateBackupRestoreJob", ctx, groupId, clusterName, diskBackupSnapshotRestoreJob)}
}

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

func (_c *CloudBackupsApi_CreateBackupRestoreJob_Call) Return(_a0 admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupSnapshotRestoreJob) admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJob_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupRestoreJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) CreateBackupRestoreJobExecute(r admin.CreateBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.CreateBackupRestoreJobApiRequest
func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call {
	return &CloudBackupsApi_CreateBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateBackupRestoreJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_CreateBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)) *CloudBackupsApi_CreateBackupRestoreJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) CreateBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateBackupRestoreJobApiParams) admin.CreateBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateBackupRestoreJobApiParams
func (_e *CloudBackupsApi_Expecter) CreateBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call {
	return &CloudBackupsApi_CreateBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateBackupRestoreJobApiParams) admin.CreateBackupRestoreJobApiRequest) *CloudBackupsApi_CreateBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateExportBucket provides a mock function with given fields: ctx, groupId, diskBackupSnapshotAWSExportBucket
func (_m *CloudBackupsApi) CreateExportBucket(ctx context.Context, groupId string, diskBackupSnapshotAWSExportBucket *admin.DiskBackupSnapshotAWSExportBucket) admin.CreateExportBucketApiRequest {
	ret := _m.Called(ctx, groupId, diskBackupSnapshotAWSExportBucket)

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

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

	return r0
}

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

// CreateExportBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - diskBackupSnapshotAWSExportBucket *admin.DiskBackupSnapshotAWSExportBucket
func (_e *CloudBackupsApi_Expecter) CreateExportBucket(ctx interface{}, groupId interface{}, diskBackupSnapshotAWSExportBucket interface{}) *CloudBackupsApi_CreateExportBucket_Call {
	return &CloudBackupsApi_CreateExportBucket_Call{Call: _e.mock.On("CreateExportBucket", ctx, groupId, diskBackupSnapshotAWSExportBucket)}
}

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

func (_c *CloudBackupsApi_CreateExportBucket_Call) Return(_a0 admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucket_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateExportBucket_Call) RunAndReturn(run func(context.Context, string, *admin.DiskBackupSnapshotAWSExportBucket) admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucket_Call {
	_c.Call.Return(run)
	return _c
}

// CreateExportBucketExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) CreateExportBucketExecute(r admin.CreateExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateExportBucketExecute is a helper method to define mock.On call
//   - r admin.CreateExportBucketApiRequest
func (_e *CloudBackupsApi_Expecter) CreateExportBucketExecute(r interface{}) *CloudBackupsApi_CreateExportBucketExecute_Call {
	return &CloudBackupsApi_CreateExportBucketExecute_Call{Call: _e.mock.On("CreateExportBucketExecute", r)}
}

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

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

func (_c *CloudBackupsApi_CreateExportBucketExecute_Call) RunAndReturn(run func(admin.CreateExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)) *CloudBackupsApi_CreateExportBucketExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateExportBucketWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) CreateExportBucketWithParams(ctx context.Context, args *admin.CreateExportBucketApiParams) admin.CreateExportBucketApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateExportBucketWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateExportBucketApiParams
func (_e *CloudBackupsApi_Expecter) CreateExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateExportBucketWithParams_Call {
	return &CloudBackupsApi_CreateExportBucketWithParams_Call{Call: _e.mock.On("CreateExportBucketWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_CreateExportBucketWithParams_Call) Return(_a0 admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucketWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateExportBucketApiParams) admin.CreateExportBucketApiRequest) *CloudBackupsApi_CreateExportBucketWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServerlessBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, serverlessBackupRestoreJob
func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJob(ctx context.Context, groupId string, clusterName string, serverlessBackupRestoreJob *admin.ServerlessBackupRestoreJob) admin.CreateServerlessBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, serverlessBackupRestoreJob)

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

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

	return r0
}

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

// CreateServerlessBackupRestoreJob is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - serverlessBackupRestoreJob *admin.ServerlessBackupRestoreJob
func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJob(ctx interface{}, groupId interface{}, clusterName interface{}, serverlessBackupRestoreJob interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call {
	return &CloudBackupsApi_CreateServerlessBackupRestoreJob_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJob", ctx, groupId, clusterName, serverlessBackupRestoreJob)}
}

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

func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call) Return(_a0 admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call) RunAndReturn(run func(context.Context, string, string, *admin.ServerlessBackupRestoreJob) admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJob_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServerlessBackupRestoreJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJobExecute(r admin.CreateServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateServerlessBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.CreateServerlessBackupRestoreJobApiRequest
func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call {
	return &CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.CreateServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_CreateServerlessBackupRestoreJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServerlessBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) CreateServerlessBackupRestoreJobWithParams(ctx context.Context, args *admin.CreateServerlessBackupRestoreJobApiParams) admin.CreateServerlessBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateServerlessBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateServerlessBackupRestoreJobApiParams
func (_e *CloudBackupsApi_Expecter) CreateServerlessBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call {
	return &CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call{Call: _e.mock.On("CreateServerlessBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call) Return(_a0 admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateServerlessBackupRestoreJobApiParams) admin.CreateServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_CreateServerlessBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_DeleteAllBackupSchedules_Call) Return(_a0 admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedules_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DeleteAllBackupSchedulesExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) DeleteAllBackupSchedulesExecute(r admin.DeleteAllBackupSchedulesApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// DeleteAllBackupSchedulesExecute is a helper method to define mock.On call
//   - r admin.DeleteAllBackupSchedulesApiRequest
func (_e *CloudBackupsApi_Expecter) DeleteAllBackupSchedulesExecute(r interface{}) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call {
	return &CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call{Call: _e.mock.On("DeleteAllBackupSchedulesExecute", r)}
}

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

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

func (_c *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call) RunAndReturn(run func(admin.DeleteAllBackupSchedulesApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_DeleteAllBackupSchedulesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllBackupSchedulesWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) DeleteAllBackupSchedulesWithParams(ctx context.Context, args *admin.DeleteAllBackupSchedulesApiParams) admin.DeleteAllBackupSchedulesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteAllBackupSchedulesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteAllBackupSchedulesApiParams
func (_e *CloudBackupsApi_Expecter) DeleteAllBackupSchedulesWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call {
	return &CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call{Call: _e.mock.On("DeleteAllBackupSchedulesWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call) Return(_a0 admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteAllBackupSchedulesApiParams) admin.DeleteAllBackupSchedulesApiRequest) *CloudBackupsApi_DeleteAllBackupSchedulesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteExportBucket provides a mock function with given fields: ctx, groupId, exportBucketId
func (_m *CloudBackupsApi) DeleteExportBucket(ctx context.Context, groupId string, exportBucketId string) admin.DeleteExportBucketApiRequest {
	ret := _m.Called(ctx, groupId, exportBucketId)

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

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

	return r0
}

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

// DeleteExportBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - exportBucketId string
func (_e *CloudBackupsApi_Expecter) DeleteExportBucket(ctx interface{}, groupId interface{}, exportBucketId interface{}) *CloudBackupsApi_DeleteExportBucket_Call {
	return &CloudBackupsApi_DeleteExportBucket_Call{Call: _e.mock.On("DeleteExportBucket", ctx, groupId, exportBucketId)}
}

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

func (_c *CloudBackupsApi_DeleteExportBucket_Call) Return(_a0 admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucket_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteExportBucketExecute is a helper method to define mock.On call
//   - r admin.DeleteExportBucketApiRequest
func (_e *CloudBackupsApi_Expecter) DeleteExportBucketExecute(r interface{}) *CloudBackupsApi_DeleteExportBucketExecute_Call {
	return &CloudBackupsApi_DeleteExportBucketExecute_Call{Call: _e.mock.On("DeleteExportBucketExecute", r)}
}

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

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

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

// DeleteExportBucketWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) DeleteExportBucketWithParams(ctx context.Context, args *admin.DeleteExportBucketApiParams) admin.DeleteExportBucketApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteExportBucketWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteExportBucketApiParams
func (_e *CloudBackupsApi_Expecter) DeleteExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteExportBucketWithParams_Call {
	return &CloudBackupsApi_DeleteExportBucketWithParams_Call{Call: _e.mock.On("DeleteExportBucketWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_DeleteExportBucketWithParams_Call) Return(_a0 admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucketWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_DeleteExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteExportBucketApiParams) admin.DeleteExportBucketApiRequest) *CloudBackupsApi_DeleteExportBucketWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_DeleteReplicaSetBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_DeleteReplicaSetBackup_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 *CloudBackupsApi_DeleteReplicaSetBackup_Call) Return(_a0 admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackup_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteReplicaSetBackupExecute is a helper method to define mock.On call
//   - r admin.DeleteReplicaSetBackupApiRequest
func (_e *CloudBackupsApi_Expecter) DeleteReplicaSetBackupExecute(r interface{}) *CloudBackupsApi_DeleteReplicaSetBackupExecute_Call {
	return &CloudBackupsApi_DeleteReplicaSetBackupExecute_Call{Call: _e.mock.On("DeleteReplicaSetBackupExecute", r)}
}

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

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

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

// DeleteReplicaSetBackupWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) DeleteReplicaSetBackupWithParams(ctx context.Context, args *admin.DeleteReplicaSetBackupApiParams) admin.DeleteReplicaSetBackupApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteReplicaSetBackupWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteReplicaSetBackupApiParams
func (_e *CloudBackupsApi_Expecter) DeleteReplicaSetBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call {
	return &CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call{Call: _e.mock.On("DeleteReplicaSetBackupWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call) Return(_a0 admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteReplicaSetBackupApiParams) admin.DeleteReplicaSetBackupApiRequest) *CloudBackupsApi_DeleteReplicaSetBackupWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_DeleteShardedClusterBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_DeleteShardedClusterBackup_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 *CloudBackupsApi_DeleteShardedClusterBackup_Call) Return(_a0 admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackup_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteShardedClusterBackupExecute is a helper method to define mock.On call
//   - r admin.DeleteShardedClusterBackupApiRequest
func (_e *CloudBackupsApi_Expecter) DeleteShardedClusterBackupExecute(r interface{}) *CloudBackupsApi_DeleteShardedClusterBackupExecute_Call {
	return &CloudBackupsApi_DeleteShardedClusterBackupExecute_Call{Call: _e.mock.On("DeleteShardedClusterBackupExecute", r)}
}

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

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

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

// DeleteShardedClusterBackupWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) DeleteShardedClusterBackupWithParams(ctx context.Context, args *admin.DeleteShardedClusterBackupApiParams) admin.DeleteShardedClusterBackupApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteShardedClusterBackupWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteShardedClusterBackupApiParams
func (_e *CloudBackupsApi_Expecter) DeleteShardedClusterBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call {
	return &CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call{Call: _e.mock.On("DeleteShardedClusterBackupWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call) Return(_a0 admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteShardedClusterBackupApiParams) admin.DeleteShardedClusterBackupApiRequest) *CloudBackupsApi_DeleteShardedClusterBackupWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupExportJob provides a mock function with given fields: ctx, groupId, clusterName, exportId
func (_m *CloudBackupsApi) GetBackupExportJob(ctx context.Context, groupId string, clusterName string, exportId string) admin.GetBackupExportJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, exportId)

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetBackupExportJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, exportId string)) *CloudBackupsApi_GetBackupExportJob_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 *CloudBackupsApi_GetBackupExportJob_Call) Return(_a0 admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJob_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetBackupExportJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetBackupExportJobExecute(r admin.GetBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetBackupExportJobExecute is a helper method to define mock.On call
//   - r admin.GetBackupExportJobApiRequest
func (_e *CloudBackupsApi_Expecter) GetBackupExportJobExecute(r interface{}) *CloudBackupsApi_GetBackupExportJobExecute_Call {
	return &CloudBackupsApi_GetBackupExportJobExecute_Call{Call: _e.mock.On("GetBackupExportJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetBackupExportJobExecute_Call) RunAndReturn(run func(admin.GetBackupExportJobApiRequest) (*admin.DiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_GetBackupExportJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupExportJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetBackupExportJobWithParams(ctx context.Context, args *admin.GetBackupExportJobApiParams) admin.GetBackupExportJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetBackupExportJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetBackupExportJobApiParams
func (_e *CloudBackupsApi_Expecter) GetBackupExportJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupExportJobWithParams_Call {
	return &CloudBackupsApi_GetBackupExportJobWithParams_Call{Call: _e.mock.On("GetBackupExportJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetBackupExportJobWithParams_Call) Return(_a0 admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetBackupExportJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupExportJobApiParams) admin.GetBackupExportJobApiRequest) *CloudBackupsApi_GetBackupExportJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId
func (_m *CloudBackupsApi) GetBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.GetBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, restoreJobId)

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_GetBackupRestoreJob_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 *CloudBackupsApi_GetBackupRestoreJob_Call) Return(_a0 admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetBackupRestoreJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetBackupRestoreJobExecute(r admin.GetBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.GetBackupRestoreJobApiRequest
func (_e *CloudBackupsApi_Expecter) GetBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_GetBackupRestoreJobExecute_Call {
	return &CloudBackupsApi_GetBackupRestoreJobExecute_Call{Call: _e.mock.On("GetBackupRestoreJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetBackupRestoreJobApiRequest) (*admin.DiskBackupSnapshotRestoreJob, *http.Response, error)) *CloudBackupsApi_GetBackupRestoreJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetBackupRestoreJobWithParams(ctx context.Context, args *admin.GetBackupRestoreJobApiParams) admin.GetBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetBackupRestoreJobApiParams
func (_e *CloudBackupsApi_Expecter) GetBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call {
	return &CloudBackupsApi_GetBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetBackupRestoreJobWithParams_Call) Return(_a0 admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupRestoreJobApiParams) admin.GetBackupRestoreJobApiRequest) *CloudBackupsApi_GetBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_GetBackupSchedule_Call) Return(_a0 admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupSchedule_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetBackupScheduleExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetBackupScheduleExecute(r admin.GetBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetBackupScheduleExecute is a helper method to define mock.On call
//   - r admin.GetBackupScheduleApiRequest
func (_e *CloudBackupsApi_Expecter) GetBackupScheduleExecute(r interface{}) *CloudBackupsApi_GetBackupScheduleExecute_Call {
	return &CloudBackupsApi_GetBackupScheduleExecute_Call{Call: _e.mock.On("GetBackupScheduleExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetBackupScheduleExecute_Call) RunAndReturn(run func(admin.GetBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_GetBackupScheduleExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetBackupScheduleWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetBackupScheduleWithParams(ctx context.Context, args *admin.GetBackupScheduleApiParams) admin.GetBackupScheduleApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetBackupScheduleWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetBackupScheduleApiParams
func (_e *CloudBackupsApi_Expecter) GetBackupScheduleWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetBackupScheduleWithParams_Call {
	return &CloudBackupsApi_GetBackupScheduleWithParams_Call{Call: _e.mock.On("GetBackupScheduleWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetBackupScheduleWithParams_Call) Return(_a0 admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupScheduleWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetBackupScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetBackupScheduleApiParams) admin.GetBackupScheduleApiRequest) *CloudBackupsApi_GetBackupScheduleWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataProtectionSettings provides a mock function with given fields: ctx, groupId
func (_m *CloudBackupsApi) GetDataProtectionSettings(ctx context.Context, groupId string) admin.GetDataProtectionSettingsApiRequest {
	ret := _m.Called(ctx, groupId)

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_GetDataProtectionSettings_Call) Return(_a0 admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettings_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetDataProtectionSettingsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetDataProtectionSettingsExecute(r admin.GetDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetDataProtectionSettingsExecute is a helper method to define mock.On call
//   - r admin.GetDataProtectionSettingsApiRequest
func (_e *CloudBackupsApi_Expecter) GetDataProtectionSettingsExecute(r interface{}) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call {
	return &CloudBackupsApi_GetDataProtectionSettingsExecute_Call{Call: _e.mock.On("GetDataProtectionSettingsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetDataProtectionSettingsExecute_Call) RunAndReturn(run func(admin.GetDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)) *CloudBackupsApi_GetDataProtectionSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataProtectionSettingsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetDataProtectionSettingsWithParams(ctx context.Context, args *admin.GetDataProtectionSettingsApiParams) admin.GetDataProtectionSettingsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetDataProtectionSettingsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetDataProtectionSettingsApiParams
func (_e *CloudBackupsApi_Expecter) GetDataProtectionSettingsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call {
	return &CloudBackupsApi_GetDataProtectionSettingsWithParams_Call{Call: _e.mock.On("GetDataProtectionSettingsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call) Return(_a0 admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDataProtectionSettingsApiParams) admin.GetDataProtectionSettingsApiRequest) *CloudBackupsApi_GetDataProtectionSettingsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetExportBucket provides a mock function with given fields: ctx, groupId, exportBucketId
func (_m *CloudBackupsApi) GetExportBucket(ctx context.Context, groupId string, exportBucketId string) admin.GetExportBucketApiRequest {
	ret := _m.Called(ctx, groupId, exportBucketId)

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

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

	return r0
}

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

// GetExportBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - exportBucketId string
func (_e *CloudBackupsApi_Expecter) GetExportBucket(ctx interface{}, groupId interface{}, exportBucketId interface{}) *CloudBackupsApi_GetExportBucket_Call {
	return &CloudBackupsApi_GetExportBucket_Call{Call: _e.mock.On("GetExportBucket", ctx, groupId, exportBucketId)}
}

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

func (_c *CloudBackupsApi_GetExportBucket_Call) Return(_a0 admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucket_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetExportBucketExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetExportBucketExecute(r admin.GetExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetExportBucketExecute is a helper method to define mock.On call
//   - r admin.GetExportBucketApiRequest
func (_e *CloudBackupsApi_Expecter) GetExportBucketExecute(r interface{}) *CloudBackupsApi_GetExportBucketExecute_Call {
	return &CloudBackupsApi_GetExportBucketExecute_Call{Call: _e.mock.On("GetExportBucketExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetExportBucketExecute_Call) RunAndReturn(run func(admin.GetExportBucketApiRequest) (*admin.DiskBackupSnapshotAWSExportBucket, *http.Response, error)) *CloudBackupsApi_GetExportBucketExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetExportBucketWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetExportBucketWithParams(ctx context.Context, args *admin.GetExportBucketApiParams) admin.GetExportBucketApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetExportBucketWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetExportBucketApiParams
func (_e *CloudBackupsApi_Expecter) GetExportBucketWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetExportBucketWithParams_Call {
	return &CloudBackupsApi_GetExportBucketWithParams_Call{Call: _e.mock.On("GetExportBucketWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetExportBucketWithParams_Call) Return(_a0 admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucketWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetExportBucketWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetExportBucketApiParams) admin.GetExportBucketApiRequest) *CloudBackupsApi_GetExportBucketWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetReplicaSetBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetReplicaSetBackup_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 *CloudBackupsApi_GetReplicaSetBackup_Call) Return(_a0 admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackup_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetReplicaSetBackupExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetReplicaSetBackupExecute(r admin.GetReplicaSetBackupApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetReplicaSetBackupExecute is a helper method to define mock.On call
//   - r admin.GetReplicaSetBackupApiRequest
func (_e *CloudBackupsApi_Expecter) GetReplicaSetBackupExecute(r interface{}) *CloudBackupsApi_GetReplicaSetBackupExecute_Call {
	return &CloudBackupsApi_GetReplicaSetBackupExecute_Call{Call: _e.mock.On("GetReplicaSetBackupExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetReplicaSetBackupExecute_Call) RunAndReturn(run func(admin.GetReplicaSetBackupApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_GetReplicaSetBackupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetReplicaSetBackupWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetReplicaSetBackupWithParams(ctx context.Context, args *admin.GetReplicaSetBackupApiParams) admin.GetReplicaSetBackupApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetReplicaSetBackupWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetReplicaSetBackupApiParams
func (_e *CloudBackupsApi_Expecter) GetReplicaSetBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call {
	return &CloudBackupsApi_GetReplicaSetBackupWithParams_Call{Call: _e.mock.On("GetReplicaSetBackupWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetReplicaSetBackupWithParams_Call) Return(_a0 admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetReplicaSetBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetReplicaSetBackupApiParams) admin.GetReplicaSetBackupApiRequest) *CloudBackupsApi_GetReplicaSetBackupWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetServerlessBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetServerlessBackup_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 *CloudBackupsApi_GetServerlessBackup_Call) Return(_a0 admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackup_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetServerlessBackupExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetServerlessBackupExecute(r admin.GetServerlessBackupApiRequest) (*admin.ServerlessBackupSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetServerlessBackupExecute is a helper method to define mock.On call
//   - r admin.GetServerlessBackupApiRequest
func (_e *CloudBackupsApi_Expecter) GetServerlessBackupExecute(r interface{}) *CloudBackupsApi_GetServerlessBackupExecute_Call {
	return &CloudBackupsApi_GetServerlessBackupExecute_Call{Call: _e.mock.On("GetServerlessBackupExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetServerlessBackupExecute_Call) RunAndReturn(run func(admin.GetServerlessBackupApiRequest) (*admin.ServerlessBackupSnapshot, *http.Response, error)) *CloudBackupsApi_GetServerlessBackupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessBackupRestoreJob provides a mock function with given fields: ctx, groupId, clusterName, restoreJobId
func (_m *CloudBackupsApi) GetServerlessBackupRestoreJob(ctx context.Context, groupId string, clusterName string, restoreJobId string) admin.GetServerlessBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, restoreJobId)

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetServerlessBackupRestoreJob_Call) Run(run func(ctx context.Context, groupId string, clusterName string, restoreJobId string)) *CloudBackupsApi_GetServerlessBackupRestoreJob_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 *CloudBackupsApi_GetServerlessBackupRestoreJob_Call) Return(_a0 admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJob_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetServerlessBackupRestoreJobExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetServerlessBackupRestoreJobExecute(r admin.GetServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetServerlessBackupRestoreJobExecute is a helper method to define mock.On call
//   - r admin.GetServerlessBackupRestoreJobApiRequest
func (_e *CloudBackupsApi_Expecter) GetServerlessBackupRestoreJobExecute(r interface{}) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call {
	return &CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call{Call: _e.mock.On("GetServerlessBackupRestoreJobExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call) RunAndReturn(run func(admin.GetServerlessBackupRestoreJobApiRequest) (*admin.ServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_GetServerlessBackupRestoreJobExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessBackupRestoreJobWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetServerlessBackupRestoreJobWithParams(ctx context.Context, args *admin.GetServerlessBackupRestoreJobApiParams) admin.GetServerlessBackupRestoreJobApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetServerlessBackupRestoreJobWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetServerlessBackupRestoreJobApiParams
func (_e *CloudBackupsApi_Expecter) GetServerlessBackupRestoreJobWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call {
	return &CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call{Call: _e.mock.On("GetServerlessBackupRestoreJobWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call) Return(_a0 admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessBackupRestoreJobApiParams) admin.GetServerlessBackupRestoreJobApiRequest) *CloudBackupsApi_GetServerlessBackupRestoreJobWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessBackupWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetServerlessBackupWithParams(ctx context.Context, args *admin.GetServerlessBackupApiParams) admin.GetServerlessBackupApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetServerlessBackupWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetServerlessBackupApiParams
func (_e *CloudBackupsApi_Expecter) GetServerlessBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetServerlessBackupWithParams_Call {
	return &CloudBackupsApi_GetServerlessBackupWithParams_Call{Call: _e.mock.On("GetServerlessBackupWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetServerlessBackupWithParams_Call) Return(_a0 admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackupWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetServerlessBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessBackupApiParams) admin.GetServerlessBackupApiRequest) *CloudBackupsApi_GetServerlessBackupWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *CloudBackupsApi_GetShardedClusterBackup_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string)) *CloudBackupsApi_GetShardedClusterBackup_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 *CloudBackupsApi_GetShardedClusterBackup_Call) Return(_a0 admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackup_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetShardedClusterBackupExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) GetShardedClusterBackupExecute(r admin.GetShardedClusterBackupApiRequest) (*admin.DiskBackupShardedClusterSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetShardedClusterBackupExecute is a helper method to define mock.On call
//   - r admin.GetShardedClusterBackupApiRequest
func (_e *CloudBackupsApi_Expecter) GetShardedClusterBackupExecute(r interface{}) *CloudBackupsApi_GetShardedClusterBackupExecute_Call {
	return &CloudBackupsApi_GetShardedClusterBackupExecute_Call{Call: _e.mock.On("GetShardedClusterBackupExecute", r)}
}

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

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

func (_c *CloudBackupsApi_GetShardedClusterBackupExecute_Call) RunAndReturn(run func(admin.GetShardedClusterBackupApiRequest) (*admin.DiskBackupShardedClusterSnapshot, *http.Response, error)) *CloudBackupsApi_GetShardedClusterBackupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetShardedClusterBackupWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) GetShardedClusterBackupWithParams(ctx context.Context, args *admin.GetShardedClusterBackupApiParams) admin.GetShardedClusterBackupApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetShardedClusterBackupWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetShardedClusterBackupApiParams
func (_e *CloudBackupsApi_Expecter) GetShardedClusterBackupWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call {
	return &CloudBackupsApi_GetShardedClusterBackupWithParams_Call{Call: _e.mock.On("GetShardedClusterBackupWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_GetShardedClusterBackupWithParams_Call) Return(_a0 admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_GetShardedClusterBackupWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetShardedClusterBackupApiParams) admin.GetShardedClusterBackupApiRequest) *CloudBackupsApi_GetShardedClusterBackupWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListBackupExportJobs_Call) Return(_a0 admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListBackupExportJobsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListBackupExportJobsExecute(r admin.ListBackupExportJobsApiRequest) (*admin.PaginatedApiAtlasDiskBackupExportJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListBackupExportJobsExecute is a helper method to define mock.On call
//   - r admin.ListBackupExportJobsApiRequest
func (_e *CloudBackupsApi_Expecter) ListBackupExportJobsExecute(r interface{}) *CloudBackupsApi_ListBackupExportJobsExecute_Call {
	return &CloudBackupsApi_ListBackupExportJobsExecute_Call{Call: _e.mock.On("ListBackupExportJobsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListBackupExportJobsExecute_Call) RunAndReturn(run func(admin.ListBackupExportJobsApiRequest) (*admin.PaginatedApiAtlasDiskBackupExportJob, *http.Response, error)) *CloudBackupsApi_ListBackupExportJobsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListBackupExportJobsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListBackupExportJobsWithParams(ctx context.Context, args *admin.ListBackupExportJobsApiParams) admin.ListBackupExportJobsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListBackupExportJobsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListBackupExportJobsApiParams
func (_e *CloudBackupsApi_Expecter) ListBackupExportJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListBackupExportJobsWithParams_Call {
	return &CloudBackupsApi_ListBackupExportJobsWithParams_Call{Call: _e.mock.On("ListBackupExportJobsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListBackupExportJobsWithParams_Call) Return(_a0 admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListBackupExportJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListBackupExportJobsApiParams) admin.ListBackupExportJobsApiRequest) *CloudBackupsApi_ListBackupExportJobsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListBackupRestoreJobs_Call) Return(_a0 admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListBackupRestoreJobsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListBackupRestoreJobsExecute(r admin.ListBackupRestoreJobsApiRequest) (*admin.PaginatedCloudBackupRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListBackupRestoreJobsExecute is a helper method to define mock.On call
//   - r admin.ListBackupRestoreJobsApiRequest
func (_e *CloudBackupsApi_Expecter) ListBackupRestoreJobsExecute(r interface{}) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call {
	return &CloudBackupsApi_ListBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListBackupRestoreJobsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListBackupRestoreJobsApiRequest) (*admin.PaginatedCloudBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_ListBackupRestoreJobsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListBackupRestoreJobsApiParams) admin.ListBackupRestoreJobsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListBackupRestoreJobsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListBackupRestoreJobsApiParams
func (_e *CloudBackupsApi_Expecter) ListBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call {
	return &CloudBackupsApi_ListBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListBackupRestoreJobsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListBackupRestoreJobsApiParams) admin.ListBackupRestoreJobsApiRequest) *CloudBackupsApi_ListBackupRestoreJobsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListExportBuckets provides a mock function with given fields: ctx, groupId
func (_m *CloudBackupsApi) ListExportBuckets(ctx context.Context, groupId string) admin.ListExportBucketsApiRequest {
	ret := _m.Called(ctx, groupId)

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListExportBuckets_Call) Return(_a0 admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBuckets_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListExportBucketsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListExportBucketsExecute(r admin.ListExportBucketsApiRequest) (*admin.PaginatedBackupSnapshotExportBucket, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListExportBucketsExecute is a helper method to define mock.On call
//   - r admin.ListExportBucketsApiRequest
func (_e *CloudBackupsApi_Expecter) ListExportBucketsExecute(r interface{}) *CloudBackupsApi_ListExportBucketsExecute_Call {
	return &CloudBackupsApi_ListExportBucketsExecute_Call{Call: _e.mock.On("ListExportBucketsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListExportBucketsExecute_Call) RunAndReturn(run func(admin.ListExportBucketsApiRequest) (*admin.PaginatedBackupSnapshotExportBucket, *http.Response, error)) *CloudBackupsApi_ListExportBucketsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListExportBucketsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListExportBucketsWithParams(ctx context.Context, args *admin.ListExportBucketsApiParams) admin.ListExportBucketsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListExportBucketsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListExportBucketsApiParams
func (_e *CloudBackupsApi_Expecter) ListExportBucketsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListExportBucketsWithParams_Call {
	return &CloudBackupsApi_ListExportBucketsWithParams_Call{Call: _e.mock.On("ListExportBucketsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListExportBucketsWithParams_Call) Return(_a0 admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBucketsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListExportBucketsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListExportBucketsApiParams) admin.ListExportBucketsApiRequest) *CloudBackupsApi_ListExportBucketsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListReplicaSetBackups_Call) Return(_a0 admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackups_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListReplicaSetBackupsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListReplicaSetBackupsExecute(r admin.ListReplicaSetBackupsApiRequest) (*admin.PaginatedCloudBackupReplicaSet, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListReplicaSetBackupsExecute is a helper method to define mock.On call
//   - r admin.ListReplicaSetBackupsApiRequest
func (_e *CloudBackupsApi_Expecter) ListReplicaSetBackupsExecute(r interface{}) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call {
	return &CloudBackupsApi_ListReplicaSetBackupsExecute_Call{Call: _e.mock.On("ListReplicaSetBackupsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListReplicaSetBackupsExecute_Call) RunAndReturn(run func(admin.ListReplicaSetBackupsApiRequest) (*admin.PaginatedCloudBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_ListReplicaSetBackupsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListReplicaSetBackupsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListReplicaSetBackupsWithParams(ctx context.Context, args *admin.ListReplicaSetBackupsApiParams) admin.ListReplicaSetBackupsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListReplicaSetBackupsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListReplicaSetBackupsApiParams
func (_e *CloudBackupsApi_Expecter) ListReplicaSetBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call {
	return &CloudBackupsApi_ListReplicaSetBackupsWithParams_Call{Call: _e.mock.On("ListReplicaSetBackupsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call) Return(_a0 admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListReplicaSetBackupsApiParams) admin.ListReplicaSetBackupsApiRequest) *CloudBackupsApi_ListReplicaSetBackupsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call) Return(_a0 admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListServerlessBackupRestoreJobsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListServerlessBackupRestoreJobsExecute(r admin.ListServerlessBackupRestoreJobsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupRestoreJob, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListServerlessBackupRestoreJobsExecute is a helper method to define mock.On call
//   - r admin.ListServerlessBackupRestoreJobsApiRequest
func (_e *CloudBackupsApi_Expecter) ListServerlessBackupRestoreJobsExecute(r interface{}) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call {
	return &CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call{Call: _e.mock.On("ListServerlessBackupRestoreJobsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call) RunAndReturn(run func(admin.ListServerlessBackupRestoreJobsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupRestoreJob, *http.Response, error)) *CloudBackupsApi_ListServerlessBackupRestoreJobsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListServerlessBackupRestoreJobsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListServerlessBackupRestoreJobsWithParams(ctx context.Context, args *admin.ListServerlessBackupRestoreJobsApiParams) admin.ListServerlessBackupRestoreJobsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListServerlessBackupRestoreJobsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListServerlessBackupRestoreJobsApiParams
func (_e *CloudBackupsApi_Expecter) ListServerlessBackupRestoreJobsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call {
	return &CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call{Call: _e.mock.On("ListServerlessBackupRestoreJobsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call) Return(_a0 admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessBackupRestoreJobsApiParams) admin.ListServerlessBackupRestoreJobsApiRequest) *CloudBackupsApi_ListServerlessBackupRestoreJobsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListServerlessBackups_Call) Return(_a0 admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackups_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListServerlessBackupsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListServerlessBackupsExecute(r admin.ListServerlessBackupsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListServerlessBackupsExecute is a helper method to define mock.On call
//   - r admin.ListServerlessBackupsApiRequest
func (_e *CloudBackupsApi_Expecter) ListServerlessBackupsExecute(r interface{}) *CloudBackupsApi_ListServerlessBackupsExecute_Call {
	return &CloudBackupsApi_ListServerlessBackupsExecute_Call{Call: _e.mock.On("ListServerlessBackupsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListServerlessBackupsExecute_Call) RunAndReturn(run func(admin.ListServerlessBackupsApiRequest) (*admin.PaginatedApiAtlasServerlessBackupSnapshot, *http.Response, error)) *CloudBackupsApi_ListServerlessBackupsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListServerlessBackupsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListServerlessBackupsWithParams(ctx context.Context, args *admin.ListServerlessBackupsApiParams) admin.ListServerlessBackupsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListServerlessBackupsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListServerlessBackupsApiParams
func (_e *CloudBackupsApi_Expecter) ListServerlessBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListServerlessBackupsWithParams_Call {
	return &CloudBackupsApi_ListServerlessBackupsWithParams_Call{Call: _e.mock.On("ListServerlessBackupsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListServerlessBackupsWithParams_Call) Return(_a0 admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackupsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListServerlessBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessBackupsApiParams) admin.ListServerlessBackupsApiRequest) *CloudBackupsApi_ListServerlessBackupsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *CloudBackupsApi_ListShardedClusterBackups_Call) Return(_a0 admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackups_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListShardedClusterBackupsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) ListShardedClusterBackupsExecute(r admin.ListShardedClusterBackupsApiRequest) (*admin.PaginatedCloudBackupShardedClusterSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListShardedClusterBackupsExecute is a helper method to define mock.On call
//   - r admin.ListShardedClusterBackupsApiRequest
func (_e *CloudBackupsApi_Expecter) ListShardedClusterBackupsExecute(r interface{}) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call {
	return &CloudBackupsApi_ListShardedClusterBackupsExecute_Call{Call: _e.mock.On("ListShardedClusterBackupsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_ListShardedClusterBackupsExecute_Call) RunAndReturn(run func(admin.ListShardedClusterBackupsApiRequest) (*admin.PaginatedCloudBackupShardedClusterSnapshot, *http.Response, error)) *CloudBackupsApi_ListShardedClusterBackupsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListShardedClusterBackupsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) ListShardedClusterBackupsWithParams(ctx context.Context, args *admin.ListShardedClusterBackupsApiParams) admin.ListShardedClusterBackupsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListShardedClusterBackupsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListShardedClusterBackupsApiParams
func (_e *CloudBackupsApi_Expecter) ListShardedClusterBackupsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call {
	return &CloudBackupsApi_ListShardedClusterBackupsWithParams_Call{Call: _e.mock.On("ListShardedClusterBackupsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call) Return(_a0 admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListShardedClusterBackupsApiParams) admin.ListShardedClusterBackupsApiRequest) *CloudBackupsApi_ListShardedClusterBackupsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// TakeSnapshot provides a mock function with given fields: ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest
func (_m *CloudBackupsApi) TakeSnapshot(ctx context.Context, groupId string, clusterName string, diskBackupOnDemandSnapshotRequest *admin.DiskBackupOnDemandSnapshotRequest) admin.TakeSnapshotApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest)

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

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

	return r0
}

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

// TakeSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - diskBackupOnDemandSnapshotRequest *admin.DiskBackupOnDemandSnapshotRequest
func (_e *CloudBackupsApi_Expecter) TakeSnapshot(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupOnDemandSnapshotRequest interface{}) *CloudBackupsApi_TakeSnapshot_Call {
	return &CloudBackupsApi_TakeSnapshot_Call{Call: _e.mock.On("TakeSnapshot", ctx, groupId, clusterName, diskBackupOnDemandSnapshotRequest)}
}

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

func (_c *CloudBackupsApi_TakeSnapshot_Call) Return(_a0 admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshot_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_TakeSnapshot_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupOnDemandSnapshotRequest) admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// TakeSnapshotExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) TakeSnapshotExecute(r admin.TakeSnapshotApiRequest) (*admin.DiskBackupSnapshot, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// TakeSnapshotExecute is a helper method to define mock.On call
//   - r admin.TakeSnapshotApiRequest
func (_e *CloudBackupsApi_Expecter) TakeSnapshotExecute(r interface{}) *CloudBackupsApi_TakeSnapshotExecute_Call {
	return &CloudBackupsApi_TakeSnapshotExecute_Call{Call: _e.mock.On("TakeSnapshotExecute", r)}
}

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

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

func (_c *CloudBackupsApi_TakeSnapshotExecute_Call) RunAndReturn(run func(admin.TakeSnapshotApiRequest) (*admin.DiskBackupSnapshot, *http.Response, error)) *CloudBackupsApi_TakeSnapshotExecute_Call {
	_c.Call.Return(run)
	return _c
}

// TakeSnapshotWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) TakeSnapshotWithParams(ctx context.Context, args *admin.TakeSnapshotApiParams) admin.TakeSnapshotApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// TakeSnapshotWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.TakeSnapshotApiParams
func (_e *CloudBackupsApi_Expecter) TakeSnapshotWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_TakeSnapshotWithParams_Call {
	return &CloudBackupsApi_TakeSnapshotWithParams_Call{Call: _e.mock.On("TakeSnapshotWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_TakeSnapshotWithParams_Call) Return(_a0 admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshotWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_TakeSnapshotWithParams_Call) RunAndReturn(run func(context.Context, *admin.TakeSnapshotApiParams) admin.TakeSnapshotApiRequest) *CloudBackupsApi_TakeSnapshotWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBackupSchedule provides a mock function with given fields: ctx, groupId, clusterName, diskBackupSnapshotSchedule
func (_m *CloudBackupsApi) UpdateBackupSchedule(ctx context.Context, groupId string, clusterName string, diskBackupSnapshotSchedule *admin.DiskBackupSnapshotSchedule) admin.UpdateBackupScheduleApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, diskBackupSnapshotSchedule)

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

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

	return r0
}

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

// UpdateBackupSchedule is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - diskBackupSnapshotSchedule *admin.DiskBackupSnapshotSchedule
func (_e *CloudBackupsApi_Expecter) UpdateBackupSchedule(ctx interface{}, groupId interface{}, clusterName interface{}, diskBackupSnapshotSchedule interface{}) *CloudBackupsApi_UpdateBackupSchedule_Call {
	return &CloudBackupsApi_UpdateBackupSchedule_Call{Call: _e.mock.On("UpdateBackupSchedule", ctx, groupId, clusterName, diskBackupSnapshotSchedule)}
}

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

func (_c *CloudBackupsApi_UpdateBackupSchedule_Call) Return(_a0 admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupSchedule_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateBackupSchedule_Call) RunAndReturn(run func(context.Context, string, string, *admin.DiskBackupSnapshotSchedule) admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupSchedule_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBackupScheduleExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) UpdateBackupScheduleExecute(r admin.UpdateBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateBackupScheduleExecute is a helper method to define mock.On call
//   - r admin.UpdateBackupScheduleApiRequest
func (_e *CloudBackupsApi_Expecter) UpdateBackupScheduleExecute(r interface{}) *CloudBackupsApi_UpdateBackupScheduleExecute_Call {
	return &CloudBackupsApi_UpdateBackupScheduleExecute_Call{Call: _e.mock.On("UpdateBackupScheduleExecute", r)}
}

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

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

func (_c *CloudBackupsApi_UpdateBackupScheduleExecute_Call) RunAndReturn(run func(admin.UpdateBackupScheduleApiRequest) (*admin.DiskBackupSnapshotSchedule, *http.Response, error)) *CloudBackupsApi_UpdateBackupScheduleExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBackupScheduleWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) UpdateBackupScheduleWithParams(ctx context.Context, args *admin.UpdateBackupScheduleApiParams) admin.UpdateBackupScheduleApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateBackupScheduleWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateBackupScheduleApiParams
func (_e *CloudBackupsApi_Expecter) UpdateBackupScheduleWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call {
	return &CloudBackupsApi_UpdateBackupScheduleWithParams_Call{Call: _e.mock.On("UpdateBackupScheduleWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_UpdateBackupScheduleWithParams_Call) Return(_a0 admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateBackupScheduleWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateBackupScheduleApiParams) admin.UpdateBackupScheduleApiRequest) *CloudBackupsApi_UpdateBackupScheduleWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDataProtectionSettings provides a mock function with given fields: ctx, groupId, dataProtectionSettings20231001
func (_m *CloudBackupsApi) UpdateDataProtectionSettings(ctx context.Context, groupId string, dataProtectionSettings20231001 *admin.DataProtectionSettings20231001) admin.UpdateDataProtectionSettingsApiRequest {
	ret := _m.Called(ctx, groupId, dataProtectionSettings20231001)

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

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

	return r0
}

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

// UpdateDataProtectionSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - dataProtectionSettings20231001 *admin.DataProtectionSettings20231001
func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettings(ctx interface{}, groupId interface{}, dataProtectionSettings20231001 interface{}) *CloudBackupsApi_UpdateDataProtectionSettings_Call {
	return &CloudBackupsApi_UpdateDataProtectionSettings_Call{Call: _e.mock.On("UpdateDataProtectionSettings", ctx, groupId, dataProtectionSettings20231001)}
}

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

func (_c *CloudBackupsApi_UpdateDataProtectionSettings_Call) Return(_a0 admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettings_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateDataProtectionSettings_Call) RunAndReturn(run func(context.Context, string, *admin.DataProtectionSettings20231001) admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettings_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDataProtectionSettingsExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) UpdateDataProtectionSettingsExecute(r admin.UpdateDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateDataProtectionSettingsExecute is a helper method to define mock.On call
//   - r admin.UpdateDataProtectionSettingsApiRequest
func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettingsExecute(r interface{}) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call {
	return &CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call{Call: _e.mock.On("UpdateDataProtectionSettingsExecute", r)}
}

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

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

func (_c *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call) RunAndReturn(run func(admin.UpdateDataProtectionSettingsApiRequest) (*admin.DataProtectionSettings20231001, *http.Response, error)) *CloudBackupsApi_UpdateDataProtectionSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDataProtectionSettingsWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) UpdateDataProtectionSettingsWithParams(ctx context.Context, args *admin.UpdateDataProtectionSettingsApiParams) admin.UpdateDataProtectionSettingsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateDataProtectionSettingsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateDataProtectionSettingsApiParams
func (_e *CloudBackupsApi_Expecter) UpdateDataProtectionSettingsWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call {
	return &CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call{Call: _e.mock.On("UpdateDataProtectionSettingsWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call) Return(_a0 admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateDataProtectionSettingsApiParams) admin.UpdateDataProtectionSettingsApiRequest) *CloudBackupsApi_UpdateDataProtectionSettingsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSnapshotRetention provides a mock function with given fields: ctx, groupId, clusterName, snapshotId, backupSnapshotRetention
func (_m *CloudBackupsApi) UpdateSnapshotRetention(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshotRetention *admin.BackupSnapshotRetention) admin.UpdateSnapshotRetentionApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, snapshotId, backupSnapshotRetention)

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

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

	return r0
}

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

// UpdateSnapshotRetention is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - snapshotId string
//   - backupSnapshotRetention *admin.BackupSnapshotRetention
func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetention(ctx interface{}, groupId interface{}, clusterName interface{}, snapshotId interface{}, backupSnapshotRetention interface{}) *CloudBackupsApi_UpdateSnapshotRetention_Call {
	return &CloudBackupsApi_UpdateSnapshotRetention_Call{Call: _e.mock.On("UpdateSnapshotRetention", ctx, groupId, clusterName, snapshotId, backupSnapshotRetention)}
}

func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) Run(run func(ctx context.Context, groupId string, clusterName string, snapshotId string, backupSnapshotRetention *admin.BackupSnapshotRetention)) *CloudBackupsApi_UpdateSnapshotRetention_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.BackupSnapshotRetention))
	})
	return _c
}

func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) Return(_a0 admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetention_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateSnapshotRetention_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupSnapshotRetention) admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetention_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSnapshotRetentionExecute provides a mock function with given fields: r
func (_m *CloudBackupsApi) UpdateSnapshotRetentionExecute(r admin.UpdateSnapshotRetentionApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateSnapshotRetentionExecute is a helper method to define mock.On call
//   - r admin.UpdateSnapshotRetentionApiRequest
func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetentionExecute(r interface{}) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call {
	return &CloudBackupsApi_UpdateSnapshotRetentionExecute_Call{Call: _e.mock.On("UpdateSnapshotRetentionExecute", r)}
}

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

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

func (_c *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call) RunAndReturn(run func(admin.UpdateSnapshotRetentionApiRequest) (*admin.DiskBackupReplicaSet, *http.Response, error)) *CloudBackupsApi_UpdateSnapshotRetentionExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSnapshotRetentionWithParams provides a mock function with given fields: ctx, args
func (_m *CloudBackupsApi) UpdateSnapshotRetentionWithParams(ctx context.Context, args *admin.UpdateSnapshotRetentionApiParams) admin.UpdateSnapshotRetentionApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateSnapshotRetentionWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateSnapshotRetentionApiParams
func (_e *CloudBackupsApi_Expecter) UpdateSnapshotRetentionWithParams(ctx interface{}, args interface{}) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call {
	return &CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call{Call: _e.mock.On("UpdateSnapshotRetentionWithParams", ctx, args)}
}

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

func (_c *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call) Return(_a0 admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateSnapshotRetentionApiParams) admin.UpdateSnapshotRetentionApiRequest) *CloudBackupsApi_UpdateSnapshotRetentionWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}