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

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

type ProgrammaticAPIKeysApi_Expecter struct {
	mock *mock.Mock
}

func (_m *ProgrammaticAPIKeysApi) EXPECT() *ProgrammaticAPIKeysApi_Expecter {
	return &ProgrammaticAPIKeysApi_Expecter{mock: &_m.Mock}
}

// AddProjectApiKey provides a mock function with given fields: ctx, groupId, apiUserId, userAccessRoleAssignment
func (_m *ProgrammaticAPIKeysApi) AddProjectApiKey(ctx context.Context, groupId string, apiUserId string, userAccessRoleAssignment *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest {
	ret := _m.Called(ctx, groupId, apiUserId, userAccessRoleAssignment)

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

	var r0 admin.AddProjectApiKeyApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest); ok {
		r0 = rf(ctx, groupId, apiUserId, userAccessRoleAssignment)
	} else {
		r0 = ret.Get(0).(admin.AddProjectApiKeyApiRequest)
	}

	return r0
}

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

// AddProjectApiKey is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - apiUserId string
//   - userAccessRoleAssignment *[]admin.UserAccessRoleAssignment
func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKey(ctx interface{}, groupId interface{}, apiUserId interface{}, userAccessRoleAssignment interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call {
	return &ProgrammaticAPIKeysApi_AddProjectApiKey_Call{Call: _e.mock.On("AddProjectApiKey", ctx, groupId, apiUserId, userAccessRoleAssignment)}
}

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) Run(run func(ctx context.Context, groupId string, apiUserId string, userAccessRoleAssignment *[]admin.UserAccessRoleAssignment)) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.UserAccessRoleAssignment))
	})
	return _c
}

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) Return(_a0 admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKey_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.UserAccessRoleAssignment) admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKey_Call {
	_c.Call.Return(run)
	return _c
}

// AddProjectApiKeyExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) AddProjectApiKeyExecute(r admin.AddProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// AddProjectApiKeyExecute is a helper method to define mock.On call
//   - r admin.AddProjectApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call{Call: _e.mock.On("AddProjectApiKeyExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call) RunAndReturn(run func(admin.AddProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_AddProjectApiKeyExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AddProjectApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) AddProjectApiKeyWithParams(ctx context.Context, args *admin.AddProjectApiKeyApiParams) admin.AddProjectApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// AddProjectApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.AddProjectApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) AddProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call{Call: _e.mock.On("AddProjectApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call) Return(_a0 admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.AddProjectApiKeyApiParams) admin.AddProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_AddProjectApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKey provides a mock function with given fields: ctx, orgId, createAtlasOrganizationApiKey
func (_m *ProgrammaticAPIKeysApi) CreateApiKey(ctx context.Context, orgId string, createAtlasOrganizationApiKey *admin.CreateAtlasOrganizationApiKey) admin.CreateApiKeyApiRequest {
	ret := _m.Called(ctx, orgId, createAtlasOrganizationApiKey)

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

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

	return r0
}

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

// CreateApiKey is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - createAtlasOrganizationApiKey *admin.CreateAtlasOrganizationApiKey
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKey(ctx interface{}, orgId interface{}, createAtlasOrganizationApiKey interface{}) *ProgrammaticAPIKeysApi_CreateApiKey_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKey_Call{Call: _e.mock.On("CreateApiKey", ctx, orgId, createAtlasOrganizationApiKey)}
}

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

func (_c *ProgrammaticAPIKeysApi_CreateApiKey_Call) Return(_a0 admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKey_Call) RunAndReturn(run func(context.Context, string, *admin.CreateAtlasOrganizationApiKey) admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKey_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKeyAccessList provides a mock function with given fields: ctx, orgId, apiUserId, userAccessListRequest
func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessList(ctx context.Context, orgId string, apiUserId string, userAccessListRequest *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId, userAccessListRequest)

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

	var r0 admin.CreateApiKeyAccessListApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest); ok {
		r0 = rf(ctx, orgId, apiUserId, userAccessListRequest)
	} else {
		r0 = ret.Get(0).(admin.CreateApiKeyAccessListApiRequest)
	}

	return r0
}

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

// CreateApiKeyAccessList is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - apiUserId string
//   - userAccessListRequest *[]admin.UserAccessListRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessList(ctx interface{}, orgId interface{}, apiUserId interface{}, userAccessListRequest interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call{Call: _e.mock.On("CreateApiKeyAccessList", ctx, orgId, apiUserId, userAccessListRequest)}
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, userAccessListRequest *[]admin.UserAccessListRequest)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*[]admin.UserAccessListRequest))
	})
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) Return(_a0 admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call) RunAndReturn(run func(context.Context, string, string, *[]admin.UserAccessListRequest) admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKeyAccessListExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessListExecute(r admin.CreateApiKeyAccessListApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateApiKeyAccessListExecute is a helper method to define mock.On call
//   - r admin.CreateApiKeyAccessListApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessListExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call{Call: _e.mock.On("CreateApiKeyAccessListExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call) RunAndReturn(run func(admin.CreateApiKeyAccessListApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKeyAccessListWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) CreateApiKeyAccessListWithParams(ctx context.Context, args *admin.CreateApiKeyAccessListApiParams) admin.CreateApiKeyAccessListApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateApiKeyAccessListWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateApiKeyAccessListApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyAccessListWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call{Call: _e.mock.On("CreateApiKeyAccessListWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call) Return(_a0 admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateApiKeyAccessListApiParams) admin.CreateApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyAccessListWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKeyExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) CreateApiKeyExecute(r admin.CreateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateApiKeyExecute is a helper method to define mock.On call
//   - r admin.CreateApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call{Call: _e.mock.On("CreateApiKeyExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call) RunAndReturn(run func(admin.CreateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateApiKeyExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) CreateApiKeyWithParams(ctx context.Context, args *admin.CreateApiKeyApiParams) admin.CreateApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call{Call: _e.mock.On("CreateApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call) Return(_a0 admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateApiKeyApiParams) admin.CreateApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateProjectApiKey provides a mock function with given fields: ctx, groupId, createAtlasProjectApiKey
func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKey(ctx context.Context, groupId string, createAtlasProjectApiKey *admin.CreateAtlasProjectApiKey) admin.CreateProjectApiKeyApiRequest {
	ret := _m.Called(ctx, groupId, createAtlasProjectApiKey)

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

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

	return r0
}

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

// CreateProjectApiKey is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - createAtlasProjectApiKey *admin.CreateAtlasProjectApiKey
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKey(ctx interface{}, groupId interface{}, createAtlasProjectApiKey interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call {
	return &ProgrammaticAPIKeysApi_CreateProjectApiKey_Call{Call: _e.mock.On("CreateProjectApiKey", ctx, groupId, createAtlasProjectApiKey)}
}

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

func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call) Return(_a0 admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call) RunAndReturn(run func(context.Context, string, *admin.CreateAtlasProjectApiKey) admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKey_Call {
	_c.Call.Return(run)
	return _c
}

// CreateProjectApiKeyExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKeyExecute(r admin.CreateProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateProjectApiKeyExecute is a helper method to define mock.On call
//   - r admin.CreateProjectApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call{Call: _e.mock.On("CreateProjectApiKeyExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call) RunAndReturn(run func(admin.CreateProjectApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_CreateProjectApiKeyExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateProjectApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) CreateProjectApiKeyWithParams(ctx context.Context, args *admin.CreateProjectApiKeyApiParams) admin.CreateProjectApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateProjectApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateProjectApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) CreateProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call{Call: _e.mock.On("CreateProjectApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call) Return(_a0 admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateProjectApiKeyApiParams) admin.CreateProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_CreateProjectApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteApiKey provides a mock function with given fields: ctx, orgId, apiUserId
func (_m *ProgrammaticAPIKeysApi) DeleteApiKey(ctx context.Context, orgId string, apiUserId string) admin.DeleteApiKeyApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId)

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_DeleteApiKey_Call) Return(_a0 admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DeleteApiKeyAccessListEntry provides a mock function with given fields: ctx, orgId, apiUserId, ipAddress
func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyAccessListEntry(ctx context.Context, orgId string, apiUserId string, ipAddress string) admin.DeleteApiKeyAccessListEntryApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId, ipAddress)

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

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

	return r0
}

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

// DeleteApiKeyAccessListEntry is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - apiUserId string
//   - ipAddress string
func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntry(ctx interface{}, orgId interface{}, apiUserId interface{}, ipAddress interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call {
	return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntry", ctx, orgId, apiUserId, ipAddress)}
}

func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, ipAddress string)) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_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 *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call) Return(_a0 admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntry_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// DeleteApiKeyAccessListEntryExecute is a helper method to define mock.On call
//   - r admin.DeleteApiKeyAccessListEntryApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntryExecute(r interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call {
	return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryExecute_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntryExecute", r)}
}

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

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

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

// DeleteApiKeyAccessListEntryWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyAccessListEntryWithParams(ctx context.Context, args *admin.DeleteApiKeyAccessListEntryApiParams) admin.DeleteApiKeyAccessListEntryApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteApiKeyAccessListEntryWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteApiKeyAccessListEntryApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyAccessListEntryWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call {
	return &ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call{Call: _e.mock.On("DeleteApiKeyAccessListEntryWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call) Return(_a0 admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteApiKeyAccessListEntryApiParams) admin.DeleteApiKeyAccessListEntryApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyAccessListEntryWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0, r1, r2
}

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

// DeleteApiKeyExecute is a helper method to define mock.On call
//   - r admin.DeleteApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_DeleteApiKeyExecute_Call{Call: _e.mock.On("DeleteApiKeyExecute", r)}
}

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

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

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

// DeleteApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) DeleteApiKeyWithParams(ctx context.Context, args *admin.DeleteApiKeyApiParams) admin.DeleteApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) DeleteApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call{Call: _e.mock.On("DeleteApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call) Return(_a0 admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteApiKeyApiParams) admin.DeleteApiKeyApiRequest) *ProgrammaticAPIKeysApi_DeleteApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetApiKey provides a mock function with given fields: ctx, orgId, apiUserId
func (_m *ProgrammaticAPIKeysApi) GetApiKey(ctx context.Context, orgId string, apiUserId string) admin.GetApiKeyApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId)

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_GetApiKey_Call) Return(_a0 admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetApiKeyAccessList provides a mock function with given fields: ctx, orgId, ipAddress, apiUserId
func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessList(ctx context.Context, orgId string, ipAddress string, apiUserId string) admin.GetApiKeyAccessListApiRequest {
	ret := _m.Called(ctx, orgId, ipAddress, apiUserId)

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

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

	return r0
}

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

// GetApiKeyAccessList is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - ipAddress string
//   - apiUserId string
func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessList(ctx interface{}, orgId interface{}, ipAddress interface{}, apiUserId interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call {
	return &ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call{Call: _e.mock.On("GetApiKeyAccessList", ctx, orgId, ipAddress, apiUserId)}
}

func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call) Run(run func(ctx context.Context, orgId string, ipAddress string, apiUserId string)) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_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 *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call) Return(_a0 admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessList_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetApiKeyAccessListExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessListExecute(r admin.GetApiKeyAccessListApiRequest) (*admin.UserAccessListResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetApiKeyAccessListExecute is a helper method to define mock.On call
//   - r admin.GetApiKeyAccessListApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessListExecute(r interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call {
	return &ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call{Call: _e.mock.On("GetApiKeyAccessListExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call) RunAndReturn(run func(admin.GetApiKeyAccessListApiRequest) (*admin.UserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_GetApiKeyAccessListExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetApiKeyAccessListWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) GetApiKeyAccessListWithParams(ctx context.Context, args *admin.GetApiKeyAccessListApiParams) admin.GetApiKeyAccessListApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetApiKeyAccessListWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetApiKeyAccessListApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyAccessListWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call {
	return &ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call{Call: _e.mock.On("GetApiKeyAccessListWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call) Return(_a0 admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetApiKeyAccessListApiParams) admin.GetApiKeyAccessListApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyAccessListWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetApiKeyExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) GetApiKeyExecute(r admin.GetApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetApiKeyExecute is a helper method to define mock.On call
//   - r admin.GetApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_GetApiKeyExecute_Call{Call: _e.mock.On("GetApiKeyExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call) RunAndReturn(run func(admin.GetApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_GetApiKeyExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) GetApiKeyWithParams(ctx context.Context, args *admin.GetApiKeyApiParams) admin.GetApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) GetApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call{Call: _e.mock.On("GetApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call) Return(_a0 admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetApiKeyApiParams) admin.GetApiKeyApiRequest) *ProgrammaticAPIKeysApi_GetApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListApiKeyAccessListsEntries provides a mock function with given fields: ctx, orgId, apiUserId
func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntries(ctx context.Context, orgId string, apiUserId string) admin.ListApiKeyAccessListsEntriesApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId)

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call) Return(_a0 admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntries_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListApiKeyAccessListsEntriesExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntriesExecute(r admin.ListApiKeyAccessListsEntriesApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListApiKeyAccessListsEntriesExecute is a helper method to define mock.On call
//   - r admin.ListApiKeyAccessListsEntriesApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeyAccessListsEntriesExecute(r interface{}) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call {
	return &ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call{Call: _e.mock.On("ListApiKeyAccessListsEntriesExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call) RunAndReturn(run func(admin.ListApiKeyAccessListsEntriesApiRequest) (*admin.PaginatedApiUserAccessListResponse, *http.Response, error)) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListApiKeyAccessListsEntriesWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) ListApiKeyAccessListsEntriesWithParams(ctx context.Context, args *admin.ListApiKeyAccessListsEntriesApiParams) admin.ListApiKeyAccessListsEntriesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListApiKeyAccessListsEntriesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListApiKeyAccessListsEntriesApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeyAccessListsEntriesWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call {
	return &ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call{Call: _e.mock.On("ListApiKeyAccessListsEntriesWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call) Return(_a0 admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListApiKeyAccessListsEntriesApiParams) admin.ListApiKeyAccessListsEntriesApiRequest) *ProgrammaticAPIKeysApi_ListApiKeyAccessListsEntriesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeys_Call) Return(_a0 admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeys_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListApiKeysExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) ListApiKeysExecute(r admin.ListApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListApiKeysExecute is a helper method to define mock.On call
//   - r admin.ListApiKeysApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeysExecute(r interface{}) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call {
	return &ProgrammaticAPIKeysApi_ListApiKeysExecute_Call{Call: _e.mock.On("ListApiKeysExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call) RunAndReturn(run func(admin.ListApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)) *ProgrammaticAPIKeysApi_ListApiKeysExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListApiKeysWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) ListApiKeysWithParams(ctx context.Context, args *admin.ListApiKeysApiParams) admin.ListApiKeysApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListApiKeysWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListApiKeysApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) ListApiKeysWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call {
	return &ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call{Call: _e.mock.On("ListApiKeysWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call) Return(_a0 admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListApiKeysApiParams) admin.ListApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListApiKeysWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call) Return(_a0 admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeys_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListProjectApiKeysExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) ListProjectApiKeysExecute(r admin.ListProjectApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListProjectApiKeysExecute is a helper method to define mock.On call
//   - r admin.ListProjectApiKeysApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) ListProjectApiKeysExecute(r interface{}) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call {
	return &ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call{Call: _e.mock.On("ListProjectApiKeysExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call) RunAndReturn(run func(admin.ListProjectApiKeysApiRequest) (*admin.PaginatedApiApiUser, *http.Response, error)) *ProgrammaticAPIKeysApi_ListProjectApiKeysExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectApiKeysWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) ListProjectApiKeysWithParams(ctx context.Context, args *admin.ListProjectApiKeysApiParams) admin.ListProjectApiKeysApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListProjectApiKeysWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListProjectApiKeysApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) ListProjectApiKeysWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call {
	return &ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call{Call: _e.mock.On("ListProjectApiKeysWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call) Return(_a0 admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListProjectApiKeysApiParams) admin.ListProjectApiKeysApiRequest) *ProgrammaticAPIKeysApi_ListProjectApiKeysWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveProjectApiKey provides a mock function with given fields: ctx, groupId, apiUserId
func (_m *ProgrammaticAPIKeysApi) RemoveProjectApiKey(ctx context.Context, groupId string, apiUserId string) admin.RemoveProjectApiKeyApiRequest {
	ret := _m.Called(ctx, groupId, apiUserId)

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

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

	return r0
}

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

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

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

func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call) Return(_a0 admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// RemoveProjectApiKeyExecute is a helper method to define mock.On call
//   - r admin.RemoveProjectApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) RemoveProjectApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_RemoveProjectApiKeyExecute_Call{Call: _e.mock.On("RemoveProjectApiKeyExecute", r)}
}

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

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

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

// RemoveProjectApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) RemoveProjectApiKeyWithParams(ctx context.Context, args *admin.RemoveProjectApiKeyApiParams) admin.RemoveProjectApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// RemoveProjectApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RemoveProjectApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) RemoveProjectApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call{Call: _e.mock.On("RemoveProjectApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call) Return(_a0 admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveProjectApiKeyApiParams) admin.RemoveProjectApiKeyApiRequest) *ProgrammaticAPIKeysApi_RemoveProjectApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKey provides a mock function with given fields: ctx, orgId, apiUserId, updateAtlasOrganizationApiKey
func (_m *ProgrammaticAPIKeysApi) UpdateApiKey(ctx context.Context, orgId string, apiUserId string, updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey) admin.UpdateApiKeyApiRequest {
	ret := _m.Called(ctx, orgId, apiUserId, updateAtlasOrganizationApiKey)

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

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

	return r0
}

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

// UpdateApiKey is a helper method to define mock.On call
//   - ctx context.Context
//   - orgId string
//   - apiUserId string
//   - updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKey(ctx interface{}, orgId interface{}, apiUserId interface{}, updateAtlasOrganizationApiKey interface{}) *ProgrammaticAPIKeysApi_UpdateApiKey_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKey_Call{Call: _e.mock.On("UpdateApiKey", ctx, orgId, apiUserId, updateAtlasOrganizationApiKey)}
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) Run(run func(ctx context.Context, orgId string, apiUserId string, updateAtlasOrganizationApiKey *admin.UpdateAtlasOrganizationApiKey)) *ProgrammaticAPIKeysApi_UpdateApiKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateAtlasOrganizationApiKey))
	})
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) Return(_a0 admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKey_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateAtlasOrganizationApiKey) admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKey_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKeyExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyExecute(r admin.UpdateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateApiKeyExecute is a helper method to define mock.On call
//   - r admin.UpdateApiKeyApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyExecute(r interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call{Call: _e.mock.On("UpdateApiKeyExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call) RunAndReturn(run func(admin.UpdateApiKeyApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_UpdateApiKeyExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKeyRoles provides a mock function with given fields: ctx, groupId, apiUserId, updateAtlasProjectApiKey
func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRoles(ctx context.Context, groupId string, apiUserId string, updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey) admin.UpdateApiKeyRolesApiRequest {
	ret := _m.Called(ctx, groupId, apiUserId, updateAtlasProjectApiKey)

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

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

	return r0
}

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

// UpdateApiKeyRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - apiUserId string
//   - updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRoles(ctx interface{}, groupId interface{}, apiUserId interface{}, updateAtlasProjectApiKey interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call{Call: _e.mock.On("UpdateApiKeyRoles", ctx, groupId, apiUserId, updateAtlasProjectApiKey)}
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) Run(run func(ctx context.Context, groupId string, apiUserId string, updateAtlasProjectApiKey *admin.UpdateAtlasProjectApiKey)) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.UpdateAtlasProjectApiKey))
	})
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) Return(_a0 admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call) RunAndReturn(run func(context.Context, string, string, *admin.UpdateAtlasProjectApiKey) admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRoles_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKeyRolesExecute provides a mock function with given fields: r
func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRolesExecute(r admin.UpdateApiKeyRolesApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateApiKeyRolesExecute is a helper method to define mock.On call
//   - r admin.UpdateApiKeyRolesApiRequest
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRolesExecute(r interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call{Call: _e.mock.On("UpdateApiKeyRolesExecute", r)}
}

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

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

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call) RunAndReturn(run func(admin.UpdateApiKeyRolesApiRequest) (*admin.ApiKeyUserDetails, *http.Response, error)) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKeyRolesWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyRolesWithParams(ctx context.Context, args *admin.UpdateApiKeyRolesApiParams) admin.UpdateApiKeyRolesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateApiKeyRolesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateApiKeyRolesApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyRolesWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call{Call: _e.mock.On("UpdateApiKeyRolesWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call) Return(_a0 admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateApiKeyRolesApiParams) admin.UpdateApiKeyRolesApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyRolesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApiKeyWithParams provides a mock function with given fields: ctx, args
func (_m *ProgrammaticAPIKeysApi) UpdateApiKeyWithParams(ctx context.Context, args *admin.UpdateApiKeyApiParams) admin.UpdateApiKeyApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateApiKeyWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateApiKeyApiParams
func (_e *ProgrammaticAPIKeysApi_Expecter) UpdateApiKeyWithParams(ctx interface{}, args interface{}) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call {
	return &ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call{Call: _e.mock.On("UpdateApiKeyWithParams", ctx, args)}
}

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

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call) Return(_a0 admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateApiKeyApiParams) admin.UpdateApiKeyApiRequest) *ProgrammaticAPIKeysApi_UpdateApiKeyWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}