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

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

type ServerlessInstancesApi_Expecter struct {
	mock *mock.Mock
}

func (_m *ServerlessInstancesApi) EXPECT() *ServerlessInstancesApi_Expecter {
	return &ServerlessInstancesApi_Expecter{mock: &_m.Mock}
}

// CreateServerlessInstance provides a mock function with given fields: ctx, groupId, serverlessInstanceDescriptionCreate
func (_m *ServerlessInstancesApi) CreateServerlessInstance(ctx context.Context, groupId string, serverlessInstanceDescriptionCreate *admin.ServerlessInstanceDescriptionCreate) admin.CreateServerlessInstanceApiRequest {
	ret := _m.Called(ctx, groupId, serverlessInstanceDescriptionCreate)

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

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

	return r0
}

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

// CreateServerlessInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - serverlessInstanceDescriptionCreate *admin.ServerlessInstanceDescriptionCreate
func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstance(ctx interface{}, groupId interface{}, serverlessInstanceDescriptionCreate interface{}) *ServerlessInstancesApi_CreateServerlessInstance_Call {
	return &ServerlessInstancesApi_CreateServerlessInstance_Call{Call: _e.mock.On("CreateServerlessInstance", ctx, groupId, serverlessInstanceDescriptionCreate)}
}

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

func (_c *ServerlessInstancesApi_CreateServerlessInstance_Call) Return(_a0 admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstance_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_CreateServerlessInstance_Call) RunAndReturn(run func(context.Context, string, *admin.ServerlessInstanceDescriptionCreate) admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstance_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServerlessInstanceExecute provides a mock function with given fields: r
func (_m *ServerlessInstancesApi) CreateServerlessInstanceExecute(r admin.CreateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateServerlessInstanceExecute is a helper method to define mock.On call
//   - r admin.CreateServerlessInstanceApiRequest
func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call {
	return &ServerlessInstancesApi_CreateServerlessInstanceExecute_Call{Call: _e.mock.On("CreateServerlessInstanceExecute", r)}
}

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

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

func (_c *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call) RunAndReturn(run func(admin.CreateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_CreateServerlessInstanceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateServerlessInstanceWithParams provides a mock function with given fields: ctx, args
func (_m *ServerlessInstancesApi) CreateServerlessInstanceWithParams(ctx context.Context, args *admin.CreateServerlessInstanceApiParams) admin.CreateServerlessInstanceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateServerlessInstanceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateServerlessInstanceApiParams
func (_e *ServerlessInstancesApi_Expecter) CreateServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call {
	return &ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call{Call: _e.mock.On("CreateServerlessInstanceWithParams", ctx, args)}
}

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

func (_c *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call) Return(_a0 admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateServerlessInstanceApiParams) admin.CreateServerlessInstanceApiRequest) *ServerlessInstancesApi_CreateServerlessInstanceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteServerlessInstance provides a mock function with given fields: ctx, groupId, name
func (_m *ServerlessInstancesApi) DeleteServerlessInstance(ctx context.Context, groupId string, name string) admin.DeleteServerlessInstanceApiRequest {
	ret := _m.Called(ctx, groupId, name)

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

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

	return r0
}

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

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

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

func (_c *ServerlessInstancesApi_DeleteServerlessInstance_Call) Return(_a0 admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstance_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteServerlessInstanceExecute is a helper method to define mock.On call
//   - r admin.DeleteServerlessInstanceApiRequest
func (_e *ServerlessInstancesApi_Expecter) DeleteServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call {
	return &ServerlessInstancesApi_DeleteServerlessInstanceExecute_Call{Call: _e.mock.On("DeleteServerlessInstanceExecute", r)}
}

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

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

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

// DeleteServerlessInstanceWithParams provides a mock function with given fields: ctx, args
func (_m *ServerlessInstancesApi) DeleteServerlessInstanceWithParams(ctx context.Context, args *admin.DeleteServerlessInstanceApiParams) admin.DeleteServerlessInstanceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteServerlessInstanceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteServerlessInstanceApiParams
func (_e *ServerlessInstancesApi_Expecter) DeleteServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call {
	return &ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call{Call: _e.mock.On("DeleteServerlessInstanceWithParams", ctx, args)}
}

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

func (_c *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call) Return(_a0 admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteServerlessInstanceApiParams) admin.DeleteServerlessInstanceApiRequest) *ServerlessInstancesApi_DeleteServerlessInstanceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessInstance provides a mock function with given fields: ctx, groupId, name
func (_m *ServerlessInstancesApi) GetServerlessInstance(ctx context.Context, groupId string, name string) admin.GetServerlessInstanceApiRequest {
	ret := _m.Called(ctx, groupId, name)

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

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

	return r0
}

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

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

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

func (_c *ServerlessInstancesApi_GetServerlessInstance_Call) Return(_a0 admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstance_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetServerlessInstanceExecute provides a mock function with given fields: r
func (_m *ServerlessInstancesApi) GetServerlessInstanceExecute(r admin.GetServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetServerlessInstanceExecute is a helper method to define mock.On call
//   - r admin.GetServerlessInstanceApiRequest
func (_e *ServerlessInstancesApi_Expecter) GetServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call {
	return &ServerlessInstancesApi_GetServerlessInstanceExecute_Call{Call: _e.mock.On("GetServerlessInstanceExecute", r)}
}

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

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

func (_c *ServerlessInstancesApi_GetServerlessInstanceExecute_Call) RunAndReturn(run func(admin.GetServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_GetServerlessInstanceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerlessInstanceWithParams provides a mock function with given fields: ctx, args
func (_m *ServerlessInstancesApi) GetServerlessInstanceWithParams(ctx context.Context, args *admin.GetServerlessInstanceApiParams) admin.GetServerlessInstanceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetServerlessInstanceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetServerlessInstanceApiParams
func (_e *ServerlessInstancesApi_Expecter) GetServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call {
	return &ServerlessInstancesApi_GetServerlessInstanceWithParams_Call{Call: _e.mock.On("GetServerlessInstanceWithParams", ctx, args)}
}

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

func (_c *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call) Return(_a0 admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetServerlessInstanceApiParams) admin.GetServerlessInstanceApiRequest) *ServerlessInstancesApi_GetServerlessInstanceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ServerlessInstancesApi_ListServerlessInstances_Call) Return(_a0 admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstances_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListServerlessInstancesExecute provides a mock function with given fields: r
func (_m *ServerlessInstancesApi) ListServerlessInstancesExecute(r admin.ListServerlessInstancesApiRequest) (*admin.PaginatedServerlessInstanceDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListServerlessInstancesExecute is a helper method to define mock.On call
//   - r admin.ListServerlessInstancesApiRequest
func (_e *ServerlessInstancesApi_Expecter) ListServerlessInstancesExecute(r interface{}) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call {
	return &ServerlessInstancesApi_ListServerlessInstancesExecute_Call{Call: _e.mock.On("ListServerlessInstancesExecute", r)}
}

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

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

func (_c *ServerlessInstancesApi_ListServerlessInstancesExecute_Call) RunAndReturn(run func(admin.ListServerlessInstancesApiRequest) (*admin.PaginatedServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_ListServerlessInstancesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListServerlessInstancesWithParams provides a mock function with given fields: ctx, args
func (_m *ServerlessInstancesApi) ListServerlessInstancesWithParams(ctx context.Context, args *admin.ListServerlessInstancesApiParams) admin.ListServerlessInstancesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListServerlessInstancesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListServerlessInstancesApiParams
func (_e *ServerlessInstancesApi_Expecter) ListServerlessInstancesWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call {
	return &ServerlessInstancesApi_ListServerlessInstancesWithParams_Call{Call: _e.mock.On("ListServerlessInstancesWithParams", ctx, args)}
}

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

func (_c *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call) Return(_a0 admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListServerlessInstancesApiParams) admin.ListServerlessInstancesApiRequest) *ServerlessInstancesApi_ListServerlessInstancesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateServerlessInstance provides a mock function with given fields: ctx, groupId, name, serverlessInstanceDescriptionUpdate
func (_m *ServerlessInstancesApi) UpdateServerlessInstance(ctx context.Context, groupId string, name string, serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate) admin.UpdateServerlessInstanceApiRequest {
	ret := _m.Called(ctx, groupId, name, serverlessInstanceDescriptionUpdate)

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

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

	return r0
}

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

// UpdateServerlessInstance is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - name string
//   - serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate
func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstance(ctx interface{}, groupId interface{}, name interface{}, serverlessInstanceDescriptionUpdate interface{}) *ServerlessInstancesApi_UpdateServerlessInstance_Call {
	return &ServerlessInstancesApi_UpdateServerlessInstance_Call{Call: _e.mock.On("UpdateServerlessInstance", ctx, groupId, name, serverlessInstanceDescriptionUpdate)}
}

func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) Run(run func(ctx context.Context, groupId string, name string, serverlessInstanceDescriptionUpdate *admin.ServerlessInstanceDescriptionUpdate)) *ServerlessInstancesApi_UpdateServerlessInstance_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ServerlessInstanceDescriptionUpdate))
	})
	return _c
}

func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) Return(_a0 admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstance_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_UpdateServerlessInstance_Call) RunAndReturn(run func(context.Context, string, string, *admin.ServerlessInstanceDescriptionUpdate) admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstance_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateServerlessInstanceExecute provides a mock function with given fields: r
func (_m *ServerlessInstancesApi) UpdateServerlessInstanceExecute(r admin.UpdateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateServerlessInstanceExecute is a helper method to define mock.On call
//   - r admin.UpdateServerlessInstanceApiRequest
func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstanceExecute(r interface{}) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call {
	return &ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call{Call: _e.mock.On("UpdateServerlessInstanceExecute", r)}
}

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

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

func (_c *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call) RunAndReturn(run func(admin.UpdateServerlessInstanceApiRequest) (*admin.ServerlessInstanceDescription, *http.Response, error)) *ServerlessInstancesApi_UpdateServerlessInstanceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateServerlessInstanceWithParams provides a mock function with given fields: ctx, args
func (_m *ServerlessInstancesApi) UpdateServerlessInstanceWithParams(ctx context.Context, args *admin.UpdateServerlessInstanceApiParams) admin.UpdateServerlessInstanceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateServerlessInstanceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateServerlessInstanceApiParams
func (_e *ServerlessInstancesApi_Expecter) UpdateServerlessInstanceWithParams(ctx interface{}, args interface{}) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call {
	return &ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call{Call: _e.mock.On("UpdateServerlessInstanceWithParams", ctx, args)}
}

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

func (_c *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call) Return(_a0 admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateServerlessInstanceApiParams) admin.UpdateServerlessInstanceApiRequest) *ServerlessInstancesApi_UpdateServerlessInstanceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}