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

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

type FederatedAuthenticationApi_Expecter struct {
	mock *mock.Mock
}

func (_m *FederatedAuthenticationApi) EXPECT() *FederatedAuthenticationApi_Expecter {
	return &FederatedAuthenticationApi_Expecter{mock: &_m.Mock}
}

// CreateIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, federationOidcIdentityProviderUpdate
func (_m *FederatedAuthenticationApi) CreateIdentityProvider(ctx context.Context, federationSettingsId string, federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest {
	ret := _m.Called(ctx, federationSettingsId, federationOidcIdentityProviderUpdate)

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

	var r0 admin.CreateIdentityProviderApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest); ok {
		r0 = rf(ctx, federationSettingsId, federationOidcIdentityProviderUpdate)
	} else {
		r0 = ret.Get(0).(admin.CreateIdentityProviderApiRequest)
	}

	return r0
}

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

// CreateIdentityProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate
func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProvider(ctx interface{}, federationSettingsId interface{}, federationOidcIdentityProviderUpdate interface{}) *FederatedAuthenticationApi_CreateIdentityProvider_Call {
	return &FederatedAuthenticationApi_CreateIdentityProvider_Call{Call: _e.mock.On("CreateIdentityProvider", ctx, federationSettingsId, federationOidcIdentityProviderUpdate)}
}

func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, federationOidcIdentityProviderUpdate *admin.FederationOidcIdentityProviderUpdate)) *FederatedAuthenticationApi_CreateIdentityProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.FederationOidcIdentityProviderUpdate))
	})
	return _c
}

func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) Return(_a0 admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProvider_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_CreateIdentityProvider_Call) RunAndReturn(run func(context.Context, string, *admin.FederationOidcIdentityProviderUpdate) admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProvider_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIdentityProviderExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) CreateIdentityProviderExecute(r admin.CreateIdentityProviderApiRequest) (*admin.FederationOidcIdentityProvider, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateIdentityProviderExecute is a helper method to define mock.On call
//   - r admin.CreateIdentityProviderApiRequest
func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call {
	return &FederatedAuthenticationApi_CreateIdentityProviderExecute_Call{Call: _e.mock.On("CreateIdentityProviderExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call) RunAndReturn(run func(admin.CreateIdentityProviderApiRequest) (*admin.FederationOidcIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_CreateIdentityProviderExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateIdentityProviderWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) CreateIdentityProviderWithParams(ctx context.Context, args *admin.CreateIdentityProviderApiParams) admin.CreateIdentityProviderApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateIdentityProviderWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateIdentityProviderApiParams
func (_e *FederatedAuthenticationApi_Expecter) CreateIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call {
	return &FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call{Call: _e.mock.On("CreateIdentityProviderWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call) Return(_a0 admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateIdentityProviderApiParams) admin.CreateIdentityProviderApiRequest) *FederatedAuthenticationApi_CreateIdentityProviderWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoleMapping provides a mock function with given fields: ctx, federationSettingsId, orgId, authFederationRoleMapping
func (_m *FederatedAuthenticationApi) CreateRoleMapping(ctx context.Context, federationSettingsId string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping) admin.CreateRoleMappingApiRequest {
	ret := _m.Called(ctx, federationSettingsId, orgId, authFederationRoleMapping)

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

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

	return r0
}

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

// CreateRoleMapping is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - orgId string
//   - authFederationRoleMapping *admin.AuthFederationRoleMapping
func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMapping(ctx interface{}, federationSettingsId interface{}, orgId interface{}, authFederationRoleMapping interface{}) *FederatedAuthenticationApi_CreateRoleMapping_Call {
	return &FederatedAuthenticationApi_CreateRoleMapping_Call{Call: _e.mock.On("CreateRoleMapping", ctx, federationSettingsId, orgId, authFederationRoleMapping)}
}

func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping)) *FederatedAuthenticationApi_CreateRoleMapping_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.AuthFederationRoleMapping))
	})
	return _c
}

func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) Return(_a0 admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMapping_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_CreateRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, *admin.AuthFederationRoleMapping) admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMapping_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoleMappingExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) CreateRoleMappingExecute(r admin.CreateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// CreateRoleMappingExecute is a helper method to define mock.On call
//   - r admin.CreateRoleMappingApiRequest
func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call {
	return &FederatedAuthenticationApi_CreateRoleMappingExecute_Call{Call: _e.mock.On("CreateRoleMappingExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_CreateRoleMappingExecute_Call) RunAndReturn(run func(admin.CreateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_CreateRoleMappingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRoleMappingWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) CreateRoleMappingWithParams(ctx context.Context, args *admin.CreateRoleMappingApiParams) admin.CreateRoleMappingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreateRoleMappingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateRoleMappingApiParams
func (_e *FederatedAuthenticationApi_Expecter) CreateRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call {
	return &FederatedAuthenticationApi_CreateRoleMappingWithParams_Call{Call: _e.mock.On("CreateRoleMappingWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call) Return(_a0 admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateRoleMappingApiParams) admin.CreateRoleMappingApiRequest) *FederatedAuthenticationApi_CreateRoleMappingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFederationApp provides a mock function with given fields: ctx, federationSettingsId
func (_m *FederatedAuthenticationApi) DeleteFederationApp(ctx context.Context, federationSettingsId string) admin.DeleteFederationAppApiRequest {
	ret := _m.Called(ctx, federationSettingsId)

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

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

	return r0
}

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

// DeleteFederationApp is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationApp(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_DeleteFederationApp_Call {
	return &FederatedAuthenticationApi_DeleteFederationApp_Call{Call: _e.mock.On("DeleteFederationApp", ctx, federationSettingsId)}
}

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

func (_c *FederatedAuthenticationApi_DeleteFederationApp_Call) Return(_a0 admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationApp_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DeleteFederationAppExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) DeleteFederationAppExecute(r admin.DeleteFederationAppApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.DeleteFederationAppApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteFederationAppExecute is a helper method to define mock.On call
//   - r admin.DeleteFederationAppApiRequest
func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationAppExecute(r interface{}) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call {
	return &FederatedAuthenticationApi_DeleteFederationAppExecute_Call{Call: _e.mock.On("DeleteFederationAppExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_DeleteFederationAppExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteFederationAppExecute_Call) RunAndReturn(run func(admin.DeleteFederationAppApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteFederationAppExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFederationAppWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) DeleteFederationAppWithParams(ctx context.Context, args *admin.DeleteFederationAppApiParams) admin.DeleteFederationAppApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteFederationAppWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteFederationAppApiParams
func (_e *FederatedAuthenticationApi_Expecter) DeleteFederationAppWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call {
	return &FederatedAuthenticationApi_DeleteFederationAppWithParams_Call{Call: _e.mock.On("DeleteFederationAppWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call) Return(_a0 admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteFederationAppApiParams) admin.DeleteFederationAppApiRequest) *FederatedAuthenticationApi_DeleteFederationAppWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId
func (_m *FederatedAuthenticationApi) DeleteIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.DeleteIdentityProviderApiRequest {
	ret := _m.Called(ctx, federationSettingsId, identityProviderId)

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

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

	return r0
}

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

// DeleteIdentityProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - identityProviderId string
func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_DeleteIdentityProvider_Call {
	return &FederatedAuthenticationApi_DeleteIdentityProvider_Call{Call: _e.mock.On("DeleteIdentityProvider", ctx, federationSettingsId, identityProviderId)}
}

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

func (_c *FederatedAuthenticationApi_DeleteIdentityProvider_Call) Return(_a0 admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProvider_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DeleteIdentityProviderExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) DeleteIdentityProviderExecute(r admin.DeleteIdentityProviderApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.DeleteIdentityProviderApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteIdentityProviderExecute is a helper method to define mock.On call
//   - r admin.DeleteIdentityProviderApiRequest
func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call {
	return &FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call{Call: _e.mock.On("DeleteIdentityProviderExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call) RunAndReturn(run func(admin.DeleteIdentityProviderApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteIdentityProviderExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIdentityProviderWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) DeleteIdentityProviderWithParams(ctx context.Context, args *admin.DeleteIdentityProviderApiParams) admin.DeleteIdentityProviderApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteIdentityProviderWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteIdentityProviderApiParams
func (_e *FederatedAuthenticationApi_Expecter) DeleteIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call {
	return &FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call{Call: _e.mock.On("DeleteIdentityProviderWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call) Return(_a0 admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteIdentityProviderApiParams) admin.DeleteIdentityProviderApiRequest) *FederatedAuthenticationApi_DeleteIdentityProviderWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId
func (_m *FederatedAuthenticationApi) DeleteRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string) admin.DeleteRoleMappingApiRequest {
	ret := _m.Called(ctx, federationSettingsId, id, orgId)

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

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

	return r0
}

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

// DeleteRoleMapping is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - id string
//   - orgId string
func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}) *FederatedAuthenticationApi_DeleteRoleMapping_Call {
	return &FederatedAuthenticationApi_DeleteRoleMapping_Call{Call: _e.mock.On("DeleteRoleMapping", ctx, federationSettingsId, id, orgId)}
}

func (_c *FederatedAuthenticationApi_DeleteRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string)) *FederatedAuthenticationApi_DeleteRoleMapping_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 *FederatedAuthenticationApi_DeleteRoleMapping_Call) Return(_a0 admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMapping_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DeleteRoleMappingExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) DeleteRoleMappingExecute(r admin.DeleteRoleMappingApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.DeleteRoleMappingApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteRoleMappingExecute is a helper method to define mock.On call
//   - r admin.DeleteRoleMappingApiRequest
func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call {
	return &FederatedAuthenticationApi_DeleteRoleMappingExecute_Call{Call: _e.mock.On("DeleteRoleMappingExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call) RunAndReturn(run func(admin.DeleteRoleMappingApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_DeleteRoleMappingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRoleMappingWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) DeleteRoleMappingWithParams(ctx context.Context, args *admin.DeleteRoleMappingApiParams) admin.DeleteRoleMappingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeleteRoleMappingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteRoleMappingApiParams
func (_e *FederatedAuthenticationApi_Expecter) DeleteRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call {
	return &FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call{Call: _e.mock.On("DeleteRoleMappingWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call) Return(_a0 admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteRoleMappingApiParams) admin.DeleteRoleMappingApiRequest) *FederatedAuthenticationApi_DeleteRoleMappingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId
func (_m *FederatedAuthenticationApi) GetConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string) admin.GetConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, federationSettingsId, orgId)

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

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

	return r0
}

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

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

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

func (_c *FederatedAuthenticationApi_GetConnectedOrgConfig_Call) Return(_a0 admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetConnectedOrgConfigExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) GetConnectedOrgConfigExecute(r admin.GetConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetConnectedOrgConfigExecute is a helper method to define mock.On call
//   - r admin.GetConnectedOrgConfigApiRequest
func (_e *FederatedAuthenticationApi_Expecter) GetConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call {
	return &FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call{Call: _e.mock.On("GetConnectedOrgConfigExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call) RunAndReturn(run func(admin.GetConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_GetConnectedOrgConfigExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) GetConnectedOrgConfigWithParams(ctx context.Context, args *admin.GetConnectedOrgConfigApiParams) admin.GetConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetConnectedOrgConfigWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetConnectedOrgConfigApiParams
func (_e *FederatedAuthenticationApi_Expecter) GetConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call {
	return &FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call{Call: _e.mock.On("GetConnectedOrgConfigWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call) Return(_a0 admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetConnectedOrgConfigApiParams) admin.GetConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_GetConnectedOrgConfigWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *FederatedAuthenticationApi_GetFederationSettings_Call) Return(_a0 admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettings_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetFederationSettingsExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) GetFederationSettingsExecute(r admin.GetFederationSettingsApiRequest) (*admin.OrgFederationSettings, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetFederationSettingsExecute is a helper method to define mock.On call
//   - r admin.GetFederationSettingsApiRequest
func (_e *FederatedAuthenticationApi_Expecter) GetFederationSettingsExecute(r interface{}) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call {
	return &FederatedAuthenticationApi_GetFederationSettingsExecute_Call{Call: _e.mock.On("GetFederationSettingsExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_GetFederationSettingsExecute_Call) RunAndReturn(run func(admin.GetFederationSettingsApiRequest) (*admin.OrgFederationSettings, *http.Response, error)) *FederatedAuthenticationApi_GetFederationSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetFederationSettingsWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) GetFederationSettingsWithParams(ctx context.Context, args *admin.GetFederationSettingsApiParams) admin.GetFederationSettingsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetFederationSettingsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetFederationSettingsApiParams
func (_e *FederatedAuthenticationApi_Expecter) GetFederationSettingsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call {
	return &FederatedAuthenticationApi_GetFederationSettingsWithParams_Call{Call: _e.mock.On("GetFederationSettingsWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call) Return(_a0 admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetFederationSettingsApiParams) admin.GetFederationSettingsApiRequest) *FederatedAuthenticationApi_GetFederationSettingsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId
func (_m *FederatedAuthenticationApi) GetIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.GetIdentityProviderApiRequest {
	ret := _m.Called(ctx, federationSettingsId, identityProviderId)

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

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

	return r0
}

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

// GetIdentityProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - identityProviderId string
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_GetIdentityProvider_Call {
	return &FederatedAuthenticationApi_GetIdentityProvider_Call{Call: _e.mock.On("GetIdentityProvider", ctx, federationSettingsId, identityProviderId)}
}

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

func (_c *FederatedAuthenticationApi_GetIdentityProvider_Call) Return(_a0 admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProvider_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetIdentityProviderExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) GetIdentityProviderExecute(r admin.GetIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetIdentityProviderExecute is a helper method to define mock.On call
//   - r admin.GetIdentityProviderApiRequest
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call {
	return &FederatedAuthenticationApi_GetIdentityProviderExecute_Call{Call: _e.mock.On("GetIdentityProviderExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_GetIdentityProviderExecute_Call) RunAndReturn(run func(admin.GetIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_GetIdentityProviderExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetIdentityProviderMetadata provides a mock function with given fields: ctx, federationSettingsId, identityProviderId
func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadata(ctx context.Context, federationSettingsId string, identityProviderId string) admin.GetIdentityProviderMetadataApiRequest {
	ret := _m.Called(ctx, federationSettingsId, identityProviderId)

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

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

	return r0
}

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

// GetIdentityProviderMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - identityProviderId string
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadata(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call {
	return &FederatedAuthenticationApi_GetIdentityProviderMetadata_Call{Call: _e.mock.On("GetIdentityProviderMetadata", ctx, federationSettingsId, identityProviderId)}
}

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

func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call) Return(_a0 admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadata_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetIdentityProviderMetadataExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadataExecute(r admin.GetIdentityProviderMetadataApiRequest) (string, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetIdentityProviderMetadataExecute is a helper method to define mock.On call
//   - r admin.GetIdentityProviderMetadataApiRequest
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadataExecute(r interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call {
	return &FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call{Call: _e.mock.On("GetIdentityProviderMetadataExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call) Return(_a0 string, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call) RunAndReturn(run func(admin.GetIdentityProviderMetadataApiRequest) (string, *http.Response, error)) *FederatedAuthenticationApi_GetIdentityProviderMetadataExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetIdentityProviderMetadataWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) GetIdentityProviderMetadataWithParams(ctx context.Context, args *admin.GetIdentityProviderMetadataApiParams) admin.GetIdentityProviderMetadataApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetIdentityProviderMetadataWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetIdentityProviderMetadataApiParams
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderMetadataWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call {
	return &FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call{Call: _e.mock.On("GetIdentityProviderMetadataWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call) Return(_a0 admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetIdentityProviderMetadataApiParams) admin.GetIdentityProviderMetadataApiRequest) *FederatedAuthenticationApi_GetIdentityProviderMetadataWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetIdentityProviderWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) GetIdentityProviderWithParams(ctx context.Context, args *admin.GetIdentityProviderApiParams) admin.GetIdentityProviderApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetIdentityProviderWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetIdentityProviderApiParams
func (_e *FederatedAuthenticationApi_Expecter) GetIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call {
	return &FederatedAuthenticationApi_GetIdentityProviderWithParams_Call{Call: _e.mock.On("GetIdentityProviderWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call) Return(_a0 admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetIdentityProviderApiParams) admin.GetIdentityProviderApiRequest) *FederatedAuthenticationApi_GetIdentityProviderWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId
func (_m *FederatedAuthenticationApi) GetRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string) admin.GetRoleMappingApiRequest {
	ret := _m.Called(ctx, federationSettingsId, id, orgId)

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

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

	return r0
}

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

// GetRoleMapping is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - id string
//   - orgId string
func (_e *FederatedAuthenticationApi_Expecter) GetRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}) *FederatedAuthenticationApi_GetRoleMapping_Call {
	return &FederatedAuthenticationApi_GetRoleMapping_Call{Call: _e.mock.On("GetRoleMapping", ctx, federationSettingsId, id, orgId)}
}

func (_c *FederatedAuthenticationApi_GetRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string)) *FederatedAuthenticationApi_GetRoleMapping_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 *FederatedAuthenticationApi_GetRoleMapping_Call) Return(_a0 admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMapping_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetRoleMappingExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) GetRoleMappingExecute(r admin.GetRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// GetRoleMappingExecute is a helper method to define mock.On call
//   - r admin.GetRoleMappingApiRequest
func (_e *FederatedAuthenticationApi_Expecter) GetRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_GetRoleMappingExecute_Call {
	return &FederatedAuthenticationApi_GetRoleMappingExecute_Call{Call: _e.mock.On("GetRoleMappingExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_GetRoleMappingExecute_Call) RunAndReturn(run func(admin.GetRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_GetRoleMappingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetRoleMappingWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) GetRoleMappingWithParams(ctx context.Context, args *admin.GetRoleMappingApiParams) admin.GetRoleMappingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetRoleMappingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetRoleMappingApiParams
func (_e *FederatedAuthenticationApi_Expecter) GetRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call {
	return &FederatedAuthenticationApi_GetRoleMappingWithParams_Call{Call: _e.mock.On("GetRoleMappingWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_GetRoleMappingWithParams_Call) Return(_a0 admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_GetRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetRoleMappingApiParams) admin.GetRoleMappingApiRequest) *FederatedAuthenticationApi_GetRoleMappingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListConnectedOrgConfigs provides a mock function with given fields: ctx, federationSettingsId
func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigs(ctx context.Context, federationSettingsId string) admin.ListConnectedOrgConfigsApiRequest {
	ret := _m.Called(ctx, federationSettingsId)

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

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

	return r0
}

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

// ListConnectedOrgConfigs is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigs(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call {
	return &FederatedAuthenticationApi_ListConnectedOrgConfigs_Call{Call: _e.mock.On("ListConnectedOrgConfigs", ctx, federationSettingsId)}
}

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

func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call) Return(_a0 admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigs_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListConnectedOrgConfigsExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigsExecute(r admin.ListConnectedOrgConfigsApiRequest) ([]admin.ConnectedOrgConfig, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListConnectedOrgConfigsExecute is a helper method to define mock.On call
//   - r admin.ListConnectedOrgConfigsApiRequest
func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigsExecute(r interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call {
	return &FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call{Call: _e.mock.On("ListConnectedOrgConfigsExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call) Return(_a0 []admin.ConnectedOrgConfig, _a1 *http.Response, _a2 error) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call) RunAndReturn(run func(admin.ListConnectedOrgConfigsApiRequest) ([]admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_ListConnectedOrgConfigsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListConnectedOrgConfigsWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) ListConnectedOrgConfigsWithParams(ctx context.Context, args *admin.ListConnectedOrgConfigsApiParams) admin.ListConnectedOrgConfigsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListConnectedOrgConfigsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListConnectedOrgConfigsApiParams
func (_e *FederatedAuthenticationApi_Expecter) ListConnectedOrgConfigsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call {
	return &FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call{Call: _e.mock.On("ListConnectedOrgConfigsWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call) Return(_a0 admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListConnectedOrgConfigsApiParams) admin.ListConnectedOrgConfigsApiRequest) *FederatedAuthenticationApi_ListConnectedOrgConfigsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListIdentityProviders provides a mock function with given fields: ctx, federationSettingsId
func (_m *FederatedAuthenticationApi) ListIdentityProviders(ctx context.Context, federationSettingsId string) admin.ListIdentityProvidersApiRequest {
	ret := _m.Called(ctx, federationSettingsId)

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

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

	return r0
}

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

// ListIdentityProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProviders(ctx interface{}, federationSettingsId interface{}) *FederatedAuthenticationApi_ListIdentityProviders_Call {
	return &FederatedAuthenticationApi_ListIdentityProviders_Call{Call: _e.mock.On("ListIdentityProviders", ctx, federationSettingsId)}
}

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

func (_c *FederatedAuthenticationApi_ListIdentityProviders_Call) Return(_a0 admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProviders_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListIdentityProvidersExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) ListIdentityProvidersExecute(r admin.ListIdentityProvidersApiRequest) (*admin.PaginatedFederationIdentityProvider, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListIdentityProvidersExecute is a helper method to define mock.On call
//   - r admin.ListIdentityProvidersApiRequest
func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProvidersExecute(r interface{}) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call {
	return &FederatedAuthenticationApi_ListIdentityProvidersExecute_Call{Call: _e.mock.On("ListIdentityProvidersExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call) RunAndReturn(run func(admin.ListIdentityProvidersApiRequest) (*admin.PaginatedFederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_ListIdentityProvidersExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListIdentityProvidersWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) ListIdentityProvidersWithParams(ctx context.Context, args *admin.ListIdentityProvidersApiParams) admin.ListIdentityProvidersApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListIdentityProvidersWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListIdentityProvidersApiParams
func (_e *FederatedAuthenticationApi_Expecter) ListIdentityProvidersWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call {
	return &FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call{Call: _e.mock.On("ListIdentityProvidersWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call) Return(_a0 admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListIdentityProvidersApiParams) admin.ListIdentityProvidersApiRequest) *FederatedAuthenticationApi_ListIdentityProvidersWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListRoleMappings provides a mock function with given fields: ctx, federationSettingsId, orgId
func (_m *FederatedAuthenticationApi) ListRoleMappings(ctx context.Context, federationSettingsId string, orgId string) admin.ListRoleMappingsApiRequest {
	ret := _m.Called(ctx, federationSettingsId, orgId)

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

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

	return r0
}

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

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

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

func (_c *FederatedAuthenticationApi_ListRoleMappings_Call) Return(_a0 admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappings_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListRoleMappingsExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) ListRoleMappingsExecute(r admin.ListRoleMappingsApiRequest) (*admin.PaginatedRoleMapping, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// ListRoleMappingsExecute is a helper method to define mock.On call
//   - r admin.ListRoleMappingsApiRequest
func (_e *FederatedAuthenticationApi_Expecter) ListRoleMappingsExecute(r interface{}) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call {
	return &FederatedAuthenticationApi_ListRoleMappingsExecute_Call{Call: _e.mock.On("ListRoleMappingsExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_ListRoleMappingsExecute_Call) RunAndReturn(run func(admin.ListRoleMappingsApiRequest) (*admin.PaginatedRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_ListRoleMappingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListRoleMappingsWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) ListRoleMappingsWithParams(ctx context.Context, args *admin.ListRoleMappingsApiParams) admin.ListRoleMappingsApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListRoleMappingsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListRoleMappingsApiParams
func (_e *FederatedAuthenticationApi_Expecter) ListRoleMappingsWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call {
	return &FederatedAuthenticationApi_ListRoleMappingsWithParams_Call{Call: _e.mock.On("ListRoleMappingsWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call) Return(_a0 admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListRoleMappingsApiParams) admin.ListRoleMappingsApiRequest) *FederatedAuthenticationApi_ListRoleMappingsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId
func (_m *FederatedAuthenticationApi) RemoveConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string) admin.RemoveConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, federationSettingsId, orgId)

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

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

	return r0
}

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

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

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

func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call) Return(_a0 admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

	return r0, r1, r2
}

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

// RemoveConnectedOrgConfigExecute is a helper method to define mock.On call
//   - r admin.RemoveConnectedOrgConfigApiRequest
func (_e *FederatedAuthenticationApi_Expecter) RemoveConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call {
	return &FederatedAuthenticationApi_RemoveConnectedOrgConfigExecute_Call{Call: _e.mock.On("RemoveConnectedOrgConfigExecute", r)}
}

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

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

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

// RemoveConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) RemoveConnectedOrgConfigWithParams(ctx context.Context, args *admin.RemoveConnectedOrgConfigApiParams) admin.RemoveConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// RemoveConnectedOrgConfigWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RemoveConnectedOrgConfigApiParams
func (_e *FederatedAuthenticationApi_Expecter) RemoveConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call {
	return &FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call{Call: _e.mock.On("RemoveConnectedOrgConfigWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call) Return(_a0 admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.RemoveConnectedOrgConfigApiParams) admin.RemoveConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_RemoveConnectedOrgConfigWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeJwksFromIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId
func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string) admin.RevokeJwksFromIdentityProviderApiRequest {
	ret := _m.Called(ctx, federationSettingsId, identityProviderId)

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

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

	return r0
}

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

// RevokeJwksFromIdentityProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - identityProviderId string
func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call {
	return &FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call{Call: _e.mock.On("RevokeJwksFromIdentityProvider", ctx, federationSettingsId, identityProviderId)}
}

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

func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call) Return(_a0 admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProvider_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// RevokeJwksFromIdentityProviderExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProviderExecute(r admin.RevokeJwksFromIdentityProviderApiRequest) (*http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.RevokeJwksFromIdentityProviderApiRequest) error); ok {
		r1 = rf(r)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RevokeJwksFromIdentityProviderExecute is a helper method to define mock.On call
//   - r admin.RevokeJwksFromIdentityProviderApiRequest
func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call {
	return &FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call{Call: _e.mock.On("RevokeJwksFromIdentityProviderExecute", r)}
}

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

func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call) Return(_a0 *http.Response, _a1 error) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call) RunAndReturn(run func(admin.RevokeJwksFromIdentityProviderApiRequest) (*http.Response, error)) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeJwksFromIdentityProviderWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) RevokeJwksFromIdentityProviderWithParams(ctx context.Context, args *admin.RevokeJwksFromIdentityProviderApiParams) admin.RevokeJwksFromIdentityProviderApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// RevokeJwksFromIdentityProviderWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.RevokeJwksFromIdentityProviderApiParams
func (_e *FederatedAuthenticationApi_Expecter) RevokeJwksFromIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call {
	return &FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call{Call: _e.mock.On("RevokeJwksFromIdentityProviderWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call) Return(_a0 admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.RevokeJwksFromIdentityProviderApiParams) admin.RevokeJwksFromIdentityProviderApiRequest) *FederatedAuthenticationApi_RevokeJwksFromIdentityProviderWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConnectedOrgConfig provides a mock function with given fields: ctx, federationSettingsId, orgId, connectedOrgConfig
func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfig(ctx context.Context, federationSettingsId string, orgId string, connectedOrgConfig *admin.ConnectedOrgConfig) admin.UpdateConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, federationSettingsId, orgId, connectedOrgConfig)

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

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

	return r0
}

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

// UpdateConnectedOrgConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - orgId string
//   - connectedOrgConfig *admin.ConnectedOrgConfig
func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfig(ctx interface{}, federationSettingsId interface{}, orgId interface{}, connectedOrgConfig interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call {
	return &FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call{Call: _e.mock.On("UpdateConnectedOrgConfig", ctx, federationSettingsId, orgId, connectedOrgConfig)}
}

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) Run(run func(ctx context.Context, federationSettingsId string, orgId string, connectedOrgConfig *admin.ConnectedOrgConfig)) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.ConnectedOrgConfig))
	})
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) Return(_a0 admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call) RunAndReturn(run func(context.Context, string, string, *admin.ConnectedOrgConfig) admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfig_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConnectedOrgConfigExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfigExecute(r admin.UpdateConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateConnectedOrgConfigExecute is a helper method to define mock.On call
//   - r admin.UpdateConnectedOrgConfigApiRequest
func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfigExecute(r interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call {
	return &FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call{Call: _e.mock.On("UpdateConnectedOrgConfigExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call) RunAndReturn(run func(admin.UpdateConnectedOrgConfigApiRequest) (*admin.ConnectedOrgConfig, *http.Response, error)) *FederatedAuthenticationApi_UpdateConnectedOrgConfigExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateConnectedOrgConfigWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) UpdateConnectedOrgConfigWithParams(ctx context.Context, args *admin.UpdateConnectedOrgConfigApiParams) admin.UpdateConnectedOrgConfigApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateConnectedOrgConfigWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateConnectedOrgConfigApiParams
func (_e *FederatedAuthenticationApi_Expecter) UpdateConnectedOrgConfigWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call {
	return &FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call{Call: _e.mock.On("UpdateConnectedOrgConfigWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call) Return(_a0 admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateConnectedOrgConfigApiParams) admin.UpdateConnectedOrgConfigApiRequest) *FederatedAuthenticationApi_UpdateConnectedOrgConfigWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateIdentityProvider provides a mock function with given fields: ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate
func (_m *FederatedAuthenticationApi) UpdateIdentityProvider(ctx context.Context, federationSettingsId string, identityProviderId string, federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest {
	ret := _m.Called(ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate)

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

	var r0 admin.UpdateIdentityProviderApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest); ok {
		r0 = rf(ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate)
	} else {
		r0 = ret.Get(0).(admin.UpdateIdentityProviderApiRequest)
	}

	return r0
}

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

// UpdateIdentityProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - identityProviderId string
//   - federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate
func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProvider(ctx interface{}, federationSettingsId interface{}, identityProviderId interface{}, federationIdentityProviderUpdate interface{}) *FederatedAuthenticationApi_UpdateIdentityProvider_Call {
	return &FederatedAuthenticationApi_UpdateIdentityProvider_Call{Call: _e.mock.On("UpdateIdentityProvider", ctx, federationSettingsId, identityProviderId, federationIdentityProviderUpdate)}
}

func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) Run(run func(ctx context.Context, federationSettingsId string, identityProviderId string, federationIdentityProviderUpdate *admin.FederationIdentityProviderUpdate)) *FederatedAuthenticationApi_UpdateIdentityProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.FederationIdentityProviderUpdate))
	})
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) Return(_a0 admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProvider_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateIdentityProvider_Call) RunAndReturn(run func(context.Context, string, string, *admin.FederationIdentityProviderUpdate) admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProvider_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateIdentityProviderExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) UpdateIdentityProviderExecute(r admin.UpdateIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateIdentityProviderExecute is a helper method to define mock.On call
//   - r admin.UpdateIdentityProviderApiRequest
func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProviderExecute(r interface{}) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call {
	return &FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call{Call: _e.mock.On("UpdateIdentityProviderExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call) RunAndReturn(run func(admin.UpdateIdentityProviderApiRequest) (*admin.FederationIdentityProvider, *http.Response, error)) *FederatedAuthenticationApi_UpdateIdentityProviderExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateIdentityProviderWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) UpdateIdentityProviderWithParams(ctx context.Context, args *admin.UpdateIdentityProviderApiParams) admin.UpdateIdentityProviderApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateIdentityProviderWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateIdentityProviderApiParams
func (_e *FederatedAuthenticationApi_Expecter) UpdateIdentityProviderWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call {
	return &FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call{Call: _e.mock.On("UpdateIdentityProviderWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call) Return(_a0 admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateIdentityProviderApiParams) admin.UpdateIdentityProviderApiRequest) *FederatedAuthenticationApi_UpdateIdentityProviderWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRoleMapping provides a mock function with given fields: ctx, federationSettingsId, id, orgId, authFederationRoleMapping
func (_m *FederatedAuthenticationApi) UpdateRoleMapping(ctx context.Context, federationSettingsId string, id string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest {
	ret := _m.Called(ctx, federationSettingsId, id, orgId, authFederationRoleMapping)

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

	var r0 admin.UpdateRoleMappingApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest); ok {
		r0 = rf(ctx, federationSettingsId, id, orgId, authFederationRoleMapping)
	} else {
		r0 = ret.Get(0).(admin.UpdateRoleMappingApiRequest)
	}

	return r0
}

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

// UpdateRoleMapping is a helper method to define mock.On call
//   - ctx context.Context
//   - federationSettingsId string
//   - id string
//   - orgId string
//   - authFederationRoleMapping *admin.AuthFederationRoleMapping
func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMapping(ctx interface{}, federationSettingsId interface{}, id interface{}, orgId interface{}, authFederationRoleMapping interface{}) *FederatedAuthenticationApi_UpdateRoleMapping_Call {
	return &FederatedAuthenticationApi_UpdateRoleMapping_Call{Call: _e.mock.On("UpdateRoleMapping", ctx, federationSettingsId, id, orgId, authFederationRoleMapping)}
}

func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) Run(run func(ctx context.Context, federationSettingsId string, id string, orgId string, authFederationRoleMapping *admin.AuthFederationRoleMapping)) *FederatedAuthenticationApi_UpdateRoleMapping_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*admin.AuthFederationRoleMapping))
	})
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) Return(_a0 admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMapping_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateRoleMapping_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.AuthFederationRoleMapping) admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMapping_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRoleMappingExecute provides a mock function with given fields: r
func (_m *FederatedAuthenticationApi) UpdateRoleMappingExecute(r admin.UpdateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error) {
	ret := _m.Called(r)

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

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

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

	return r0, r1, r2
}

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

// UpdateRoleMappingExecute is a helper method to define mock.On call
//   - r admin.UpdateRoleMappingApiRequest
func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMappingExecute(r interface{}) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call {
	return &FederatedAuthenticationApi_UpdateRoleMappingExecute_Call{Call: _e.mock.On("UpdateRoleMappingExecute", r)}
}

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

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

func (_c *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call) RunAndReturn(run func(admin.UpdateRoleMappingApiRequest) (*admin.AuthFederationRoleMapping, *http.Response, error)) *FederatedAuthenticationApi_UpdateRoleMappingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRoleMappingWithParams provides a mock function with given fields: ctx, args
func (_m *FederatedAuthenticationApi) UpdateRoleMappingWithParams(ctx context.Context, args *admin.UpdateRoleMappingApiParams) admin.UpdateRoleMappingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// UpdateRoleMappingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateRoleMappingApiParams
func (_e *FederatedAuthenticationApi_Expecter) UpdateRoleMappingWithParams(ctx interface{}, args interface{}) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call {
	return &FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call{Call: _e.mock.On("UpdateRoleMappingWithParams", ctx, args)}
}

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

func (_c *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call) Return(_a0 admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateRoleMappingApiParams) admin.UpdateRoleMappingApiRequest) *FederatedAuthenticationApi_UpdateRoleMappingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}