online_archive_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"

	io "io"

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

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

type OnlineArchiveApi_Expecter struct {
	mock *mock.Mock
}

func (_m *OnlineArchiveApi) EXPECT() *OnlineArchiveApi_Expecter {
	return &OnlineArchiveApi_Expecter{mock: &_m.Mock}
}

// CreateOnlineArchive provides a mock function with given fields: ctx, groupId, clusterName, backupOnlineArchiveCreate
func (_m *OnlineArchiveApi) CreateOnlineArchive(ctx context.Context, groupId string, clusterName string, backupOnlineArchiveCreate *admin.BackupOnlineArchiveCreate) admin.CreateOnlineArchiveApiRequest {
	ret := _m.Called(ctx, groupId, clusterName, backupOnlineArchiveCreate)

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

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

	return r0
}

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

// CreateOnlineArchive is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - clusterName string
//   - backupOnlineArchiveCreate *admin.BackupOnlineArchiveCreate
func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchive(ctx interface{}, groupId interface{}, clusterName interface{}, backupOnlineArchiveCreate interface{}) *OnlineArchiveApi_CreateOnlineArchive_Call {
	return &OnlineArchiveApi_CreateOnlineArchive_Call{Call: _e.mock.On("CreateOnlineArchive", ctx, groupId, clusterName, backupOnlineArchiveCreate)}
}

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

func (_c *OnlineArchiveApi_CreateOnlineArchive_Call) Return(_a0 admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchive_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_CreateOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, *admin.BackupOnlineArchiveCreate) admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchive_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOnlineArchiveExecute provides a mock function with given fields: r
func (_m *OnlineArchiveApi) CreateOnlineArchiveExecute(r admin.CreateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateOnlineArchiveExecute is a helper method to define mock.On call
//   - r admin.CreateOnlineArchiveApiRequest
func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call {
	return &OnlineArchiveApi_CreateOnlineArchiveExecute_Call{Call: _e.mock.On("CreateOnlineArchiveExecute", r)}
}

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

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

func (_c *OnlineArchiveApi_CreateOnlineArchiveExecute_Call) RunAndReturn(run func(admin.CreateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_CreateOnlineArchiveExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOnlineArchiveWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) CreateOnlineArchiveWithParams(ctx context.Context, args *admin.CreateOnlineArchiveApiParams) admin.CreateOnlineArchiveApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateOnlineArchiveWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateOnlineArchiveApiParams
func (_e *OnlineArchiveApi_Expecter) CreateOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call {
	return &OnlineArchiveApi_CreateOnlineArchiveWithParams_Call{Call: _e.mock.On("CreateOnlineArchiveWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call) Return(_a0 admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOnlineArchiveApiParams) admin.CreateOnlineArchiveApiRequest) *OnlineArchiveApi_CreateOnlineArchiveWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName
func (_m *OnlineArchiveApi) DeleteOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string) admin.DeleteOnlineArchiveApiRequest {
	ret := _m.Called(ctx, groupId, archiveId, clusterName)

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

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

	return r0
}

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

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

func (_c *OnlineArchiveApi_DeleteOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string)) *OnlineArchiveApi_DeleteOnlineArchive_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 *OnlineArchiveApi_DeleteOnlineArchive_Call) Return(_a0 admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchive_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteOnlineArchiveExecute is a helper method to define mock.On call
//   - r admin.DeleteOnlineArchiveApiRequest
func (_e *OnlineArchiveApi_Expecter) DeleteOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_DeleteOnlineArchiveExecute_Call {
	return &OnlineArchiveApi_DeleteOnlineArchiveExecute_Call{Call: _e.mock.On("DeleteOnlineArchiveExecute", r)}
}

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

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

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

// DeleteOnlineArchiveWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) DeleteOnlineArchiveWithParams(ctx context.Context, args *admin.DeleteOnlineArchiveApiParams) admin.DeleteOnlineArchiveApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteOnlineArchiveWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteOnlineArchiveApiParams
func (_e *OnlineArchiveApi_Expecter) DeleteOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call {
	return &OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call{Call: _e.mock.On("DeleteOnlineArchiveWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call) Return(_a0 admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOnlineArchiveApiParams) admin.DeleteOnlineArchiveApiRequest) *OnlineArchiveApi_DeleteOnlineArchiveWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call) Return(_a0 admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DownloadOnlineArchiveQueryLogsExecute provides a mock function with given fields: r
func (_m *OnlineArchiveApi) DownloadOnlineArchiveQueryLogsExecute(r admin.DownloadOnlineArchiveQueryLogsApiRequest) (io.ReadCloser, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// DownloadOnlineArchiveQueryLogsExecute is a helper method to define mock.On call
//   - r admin.DownloadOnlineArchiveQueryLogsApiRequest
func (_e *OnlineArchiveApi_Expecter) DownloadOnlineArchiveQueryLogsExecute(r interface{}) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call {
	return &OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call{Call: _e.mock.On("DownloadOnlineArchiveQueryLogsExecute", r)}
}

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

func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call) RunAndReturn(run func(admin.DownloadOnlineArchiveQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadOnlineArchiveQueryLogsWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) DownloadOnlineArchiveQueryLogsWithParams(ctx context.Context, args *admin.DownloadOnlineArchiveQueryLogsApiParams) admin.DownloadOnlineArchiveQueryLogsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DownloadOnlineArchiveQueryLogsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DownloadOnlineArchiveQueryLogsApiParams
func (_e *OnlineArchiveApi_Expecter) DownloadOnlineArchiveQueryLogsWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call {
	return &OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call{Call: _e.mock.On("DownloadOnlineArchiveQueryLogsWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call) Return(_a0 admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadOnlineArchiveQueryLogsApiParams) admin.DownloadOnlineArchiveQueryLogsApiRequest) *OnlineArchiveApi_DownloadOnlineArchiveQueryLogsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName
func (_m *OnlineArchiveApi) GetOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string) admin.GetOnlineArchiveApiRequest {
	ret := _m.Called(ctx, groupId, archiveId, clusterName)

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

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

	return r0
}

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

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

func (_c *OnlineArchiveApi_GetOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string)) *OnlineArchiveApi_GetOnlineArchive_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 *OnlineArchiveApi_GetOnlineArchive_Call) Return(_a0 admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchive_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetOnlineArchiveExecute provides a mock function with given fields: r
func (_m *OnlineArchiveApi) GetOnlineArchiveExecute(r admin.GetOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetOnlineArchiveExecute is a helper method to define mock.On call
//   - r admin.GetOnlineArchiveApiRequest
func (_e *OnlineArchiveApi_Expecter) GetOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_GetOnlineArchiveExecute_Call {
	return &OnlineArchiveApi_GetOnlineArchiveExecute_Call{Call: _e.mock.On("GetOnlineArchiveExecute", r)}
}

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

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

func (_c *OnlineArchiveApi_GetOnlineArchiveExecute_Call) RunAndReturn(run func(admin.GetOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_GetOnlineArchiveExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetOnlineArchiveWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) GetOnlineArchiveWithParams(ctx context.Context, args *admin.GetOnlineArchiveApiParams) admin.GetOnlineArchiveApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetOnlineArchiveWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetOnlineArchiveApiParams
func (_e *OnlineArchiveApi_Expecter) GetOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call {
	return &OnlineArchiveApi_GetOnlineArchiveWithParams_Call{Call: _e.mock.On("GetOnlineArchiveWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_GetOnlineArchiveWithParams_Call) Return(_a0 admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_GetOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetOnlineArchiveApiParams) admin.GetOnlineArchiveApiRequest) *OnlineArchiveApi_GetOnlineArchiveWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *OnlineArchiveApi_ListOnlineArchives_Call) Return(_a0 admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchives_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListOnlineArchivesExecute provides a mock function with given fields: r
func (_m *OnlineArchiveApi) ListOnlineArchivesExecute(r admin.ListOnlineArchivesApiRequest) (*admin.PaginatedOnlineArchive, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListOnlineArchivesExecute is a helper method to define mock.On call
//   - r admin.ListOnlineArchivesApiRequest
func (_e *OnlineArchiveApi_Expecter) ListOnlineArchivesExecute(r interface{}) *OnlineArchiveApi_ListOnlineArchivesExecute_Call {
	return &OnlineArchiveApi_ListOnlineArchivesExecute_Call{Call: _e.mock.On("ListOnlineArchivesExecute", r)}
}

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

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

func (_c *OnlineArchiveApi_ListOnlineArchivesExecute_Call) RunAndReturn(run func(admin.ListOnlineArchivesApiRequest) (*admin.PaginatedOnlineArchive, *http.Response, error)) *OnlineArchiveApi_ListOnlineArchivesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListOnlineArchivesWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) ListOnlineArchivesWithParams(ctx context.Context, args *admin.ListOnlineArchivesApiParams) admin.ListOnlineArchivesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListOnlineArchivesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListOnlineArchivesApiParams
func (_e *OnlineArchiveApi_Expecter) ListOnlineArchivesWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call {
	return &OnlineArchiveApi_ListOnlineArchivesWithParams_Call{Call: _e.mock.On("ListOnlineArchivesWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_ListOnlineArchivesWithParams_Call) Return(_a0 admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_ListOnlineArchivesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListOnlineArchivesApiParams) admin.ListOnlineArchivesApiRequest) *OnlineArchiveApi_ListOnlineArchivesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOnlineArchive provides a mock function with given fields: ctx, groupId, archiveId, clusterName, backupOnlineArchive
func (_m *OnlineArchiveApi) UpdateOnlineArchive(ctx context.Context, groupId string, archiveId string, clusterName string, backupOnlineArchive *admin.BackupOnlineArchive) admin.UpdateOnlineArchiveApiRequest {
	ret := _m.Called(ctx, groupId, archiveId, clusterName, backupOnlineArchive)

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

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

	return r0
}

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

// UpdateOnlineArchive is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - archiveId string
//   - clusterName string
//   - backupOnlineArchive *admin.BackupOnlineArchive
func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchive(ctx interface{}, groupId interface{}, archiveId interface{}, clusterName interface{}, backupOnlineArchive interface{}) *OnlineArchiveApi_UpdateOnlineArchive_Call {
	return &OnlineArchiveApi_UpdateOnlineArchive_Call{Call: _e.mock.On("UpdateOnlineArchive", ctx, groupId, archiveId, clusterName, backupOnlineArchive)}
}

func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) Run(run func(ctx context.Context, groupId string, archiveId string, clusterName string, backupOnlineArchive *admin.BackupOnlineArchive)) *OnlineArchiveApi_UpdateOnlineArchive_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.BackupOnlineArchive))
	})
	return _c
}

func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) Return(_a0 admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchive_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_UpdateOnlineArchive_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.BackupOnlineArchive) admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchive_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOnlineArchiveExecute provides a mock function with given fields: r
func (_m *OnlineArchiveApi) UpdateOnlineArchiveExecute(r admin.UpdateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateOnlineArchiveExecute is a helper method to define mock.On call
//   - r admin.UpdateOnlineArchiveApiRequest
func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchiveExecute(r interface{}) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call {
	return &OnlineArchiveApi_UpdateOnlineArchiveExecute_Call{Call: _e.mock.On("UpdateOnlineArchiveExecute", r)}
}

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

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

func (_c *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call) RunAndReturn(run func(admin.UpdateOnlineArchiveApiRequest) (*admin.BackupOnlineArchive, *http.Response, error)) *OnlineArchiveApi_UpdateOnlineArchiveExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOnlineArchiveWithParams provides a mock function with given fields: ctx, args
func (_m *OnlineArchiveApi) UpdateOnlineArchiveWithParams(ctx context.Context, args *admin.UpdateOnlineArchiveApiParams) admin.UpdateOnlineArchiveApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateOnlineArchiveWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateOnlineArchiveApiParams
func (_e *OnlineArchiveApi_Expecter) UpdateOnlineArchiveWithParams(ctx interface{}, args interface{}) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call {
	return &OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call{Call: _e.mock.On("UpdateOnlineArchiveWithParams", ctx, args)}
}

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

func (_c *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call) Return(_a0 admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateOnlineArchiveApiParams) admin.UpdateOnlineArchiveApiRequest) *OnlineArchiveApi_UpdateOnlineArchiveWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}