// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/oidc/v3/pkg/op (interfaces: Configuration)

// Package mock is a generated GoMock package.
package mock

import (
	http "net/http"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	op "github.com/zitadel/oidc/v3/pkg/op"
	language "golang.org/x/text/language"
)

// MockConfiguration is a mock of Configuration interface.
type MockConfiguration struct {
	ctrl     *gomock.Controller
	recorder *MockConfigurationMockRecorder
}

// MockConfigurationMockRecorder is the mock recorder for MockConfiguration.
type MockConfigurationMockRecorder struct {
	mock *MockConfiguration
}

// NewMockConfiguration creates a new mock instance.
func NewMockConfiguration(ctrl *gomock.Controller) *MockConfiguration {
	mock := &MockConfiguration{ctrl: ctrl}
	mock.recorder = &MockConfigurationMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfiguration) EXPECT() *MockConfigurationMockRecorder {
	return m.recorder
}

// AuthMethodPostSupported mocks base method.
func (m *MockConfiguration) AuthMethodPostSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthMethodPostSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// AuthMethodPostSupported indicates an expected call of AuthMethodPostSupported.
func (mr *MockConfigurationMockRecorder) AuthMethodPostSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthMethodPostSupported", reflect.TypeOf((*MockConfiguration)(nil).AuthMethodPostSupported))
}

// AuthMethodPrivateKeyJWTSupported mocks base method.
func (m *MockConfiguration) AuthMethodPrivateKeyJWTSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthMethodPrivateKeyJWTSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// AuthMethodPrivateKeyJWTSupported indicates an expected call of AuthMethodPrivateKeyJWTSupported.
func (mr *MockConfigurationMockRecorder) AuthMethodPrivateKeyJWTSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthMethodPrivateKeyJWTSupported", reflect.TypeOf((*MockConfiguration)(nil).AuthMethodPrivateKeyJWTSupported))
}

// AuthorizationEndpoint mocks base method.
func (m *MockConfiguration) AuthorizationEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizationEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// AuthorizationEndpoint indicates an expected call of AuthorizationEndpoint.
func (mr *MockConfigurationMockRecorder) AuthorizationEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizationEndpoint", reflect.TypeOf((*MockConfiguration)(nil).AuthorizationEndpoint))
}

// BackChannelLogoutSessionSupported mocks base method.
func (m *MockConfiguration) BackChannelLogoutSessionSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackChannelLogoutSessionSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// BackChannelLogoutSessionSupported indicates an expected call of BackChannelLogoutSessionSupported.
func (mr *MockConfigurationMockRecorder) BackChannelLogoutSessionSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackChannelLogoutSessionSupported", reflect.TypeOf((*MockConfiguration)(nil).BackChannelLogoutSessionSupported))
}

// BackChannelLogoutSupported mocks base method.
func (m *MockConfiguration) BackChannelLogoutSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackChannelLogoutSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// BackChannelLogoutSupported indicates an expected call of BackChannelLogoutSupported.
func (mr *MockConfigurationMockRecorder) BackChannelLogoutSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackChannelLogoutSupported", reflect.TypeOf((*MockConfiguration)(nil).BackChannelLogoutSupported))
}

// CheckSessionIframe mocks base method.
func (m *MockConfiguration) CheckSessionIframe() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckSessionIframe")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// CheckSessionIframe indicates an expected call of CheckSessionIframe.
func (mr *MockConfigurationMockRecorder) CheckSessionIframe() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSessionIframe", reflect.TypeOf((*MockConfiguration)(nil).CheckSessionIframe))
}

// CodeMethodS256Supported mocks base method.
func (m *MockConfiguration) CodeMethodS256Supported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CodeMethodS256Supported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// CodeMethodS256Supported indicates an expected call of CodeMethodS256Supported.
func (mr *MockConfigurationMockRecorder) CodeMethodS256Supported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeMethodS256Supported", reflect.TypeOf((*MockConfiguration)(nil).CodeMethodS256Supported))
}

// DeviceAuthorization mocks base method.
func (m *MockConfiguration) DeviceAuthorization() op.DeviceAuthorizationConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeviceAuthorization")
	ret0, _ := ret[0].(op.DeviceAuthorizationConfig)
	return ret0
}

// DeviceAuthorization indicates an expected call of DeviceAuthorization.
func (mr *MockConfigurationMockRecorder) DeviceAuthorization() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeviceAuthorization", reflect.TypeOf((*MockConfiguration)(nil).DeviceAuthorization))
}

// DeviceAuthorizationEndpoint mocks base method.
func (m *MockConfiguration) DeviceAuthorizationEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeviceAuthorizationEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// DeviceAuthorizationEndpoint indicates an expected call of DeviceAuthorizationEndpoint.
func (mr *MockConfigurationMockRecorder) DeviceAuthorizationEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeviceAuthorizationEndpoint", reflect.TypeOf((*MockConfiguration)(nil).DeviceAuthorizationEndpoint))
}

// EndSessionEndpoint mocks base method.
func (m *MockConfiguration) EndSessionEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EndSessionEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// EndSessionEndpoint indicates an expected call of EndSessionEndpoint.
func (mr *MockConfigurationMockRecorder) EndSessionEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndSessionEndpoint", reflect.TypeOf((*MockConfiguration)(nil).EndSessionEndpoint))
}

// GrantTypeClientCredentialsSupported mocks base method.
func (m *MockConfiguration) GrantTypeClientCredentialsSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantTypeClientCredentialsSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GrantTypeClientCredentialsSupported indicates an expected call of GrantTypeClientCredentialsSupported.
func (mr *MockConfigurationMockRecorder) GrantTypeClientCredentialsSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantTypeClientCredentialsSupported", reflect.TypeOf((*MockConfiguration)(nil).GrantTypeClientCredentialsSupported))
}

// GrantTypeDeviceCodeSupported mocks base method.
func (m *MockConfiguration) GrantTypeDeviceCodeSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantTypeDeviceCodeSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GrantTypeDeviceCodeSupported indicates an expected call of GrantTypeDeviceCodeSupported.
func (mr *MockConfigurationMockRecorder) GrantTypeDeviceCodeSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantTypeDeviceCodeSupported", reflect.TypeOf((*MockConfiguration)(nil).GrantTypeDeviceCodeSupported))
}

// GrantTypeJWTAuthorizationSupported mocks base method.
func (m *MockConfiguration) GrantTypeJWTAuthorizationSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantTypeJWTAuthorizationSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GrantTypeJWTAuthorizationSupported indicates an expected call of GrantTypeJWTAuthorizationSupported.
func (mr *MockConfigurationMockRecorder) GrantTypeJWTAuthorizationSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantTypeJWTAuthorizationSupported", reflect.TypeOf((*MockConfiguration)(nil).GrantTypeJWTAuthorizationSupported))
}

// GrantTypeRefreshTokenSupported mocks base method.
func (m *MockConfiguration) GrantTypeRefreshTokenSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantTypeRefreshTokenSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GrantTypeRefreshTokenSupported indicates an expected call of GrantTypeRefreshTokenSupported.
func (mr *MockConfigurationMockRecorder) GrantTypeRefreshTokenSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantTypeRefreshTokenSupported", reflect.TypeOf((*MockConfiguration)(nil).GrantTypeRefreshTokenSupported))
}

// GrantTypeTokenExchangeSupported mocks base method.
func (m *MockConfiguration) GrantTypeTokenExchangeSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GrantTypeTokenExchangeSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GrantTypeTokenExchangeSupported indicates an expected call of GrantTypeTokenExchangeSupported.
func (mr *MockConfigurationMockRecorder) GrantTypeTokenExchangeSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GrantTypeTokenExchangeSupported", reflect.TypeOf((*MockConfiguration)(nil).GrantTypeTokenExchangeSupported))
}

// Insecure mocks base method.
func (m *MockConfiguration) Insecure() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insecure")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Insecure indicates an expected call of Insecure.
func (mr *MockConfigurationMockRecorder) Insecure() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insecure", reflect.TypeOf((*MockConfiguration)(nil).Insecure))
}

// IntrospectionAuthMethodPrivateKeyJWTSupported mocks base method.
func (m *MockConfiguration) IntrospectionAuthMethodPrivateKeyJWTSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IntrospectionAuthMethodPrivateKeyJWTSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IntrospectionAuthMethodPrivateKeyJWTSupported indicates an expected call of IntrospectionAuthMethodPrivateKeyJWTSupported.
func (mr *MockConfigurationMockRecorder) IntrospectionAuthMethodPrivateKeyJWTSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntrospectionAuthMethodPrivateKeyJWTSupported", reflect.TypeOf((*MockConfiguration)(nil).IntrospectionAuthMethodPrivateKeyJWTSupported))
}

// IntrospectionEndpoint mocks base method.
func (m *MockConfiguration) IntrospectionEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IntrospectionEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// IntrospectionEndpoint indicates an expected call of IntrospectionEndpoint.
func (mr *MockConfigurationMockRecorder) IntrospectionEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntrospectionEndpoint", reflect.TypeOf((*MockConfiguration)(nil).IntrospectionEndpoint))
}

// IntrospectionEndpointSigningAlgorithmsSupported mocks base method.
func (m *MockConfiguration) IntrospectionEndpointSigningAlgorithmsSupported() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IntrospectionEndpointSigningAlgorithmsSupported")
	ret0, _ := ret[0].([]string)
	return ret0
}

// IntrospectionEndpointSigningAlgorithmsSupported indicates an expected call of IntrospectionEndpointSigningAlgorithmsSupported.
func (mr *MockConfigurationMockRecorder) IntrospectionEndpointSigningAlgorithmsSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IntrospectionEndpointSigningAlgorithmsSupported", reflect.TypeOf((*MockConfiguration)(nil).IntrospectionEndpointSigningAlgorithmsSupported))
}

// IssuerFromRequest mocks base method.
func (m *MockConfiguration) IssuerFromRequest(arg0 *http.Request) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IssuerFromRequest", arg0)
	ret0, _ := ret[0].(string)
	return ret0
}

// IssuerFromRequest indicates an expected call of IssuerFromRequest.
func (mr *MockConfigurationMockRecorder) IssuerFromRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IssuerFromRequest", reflect.TypeOf((*MockConfiguration)(nil).IssuerFromRequest), arg0)
}

// KeysEndpoint mocks base method.
func (m *MockConfiguration) KeysEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KeysEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// KeysEndpoint indicates an expected call of KeysEndpoint.
func (mr *MockConfigurationMockRecorder) KeysEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeysEndpoint", reflect.TypeOf((*MockConfiguration)(nil).KeysEndpoint))
}

// RequestObjectSigningAlgorithmsSupported mocks base method.
func (m *MockConfiguration) RequestObjectSigningAlgorithmsSupported() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestObjectSigningAlgorithmsSupported")
	ret0, _ := ret[0].([]string)
	return ret0
}

// RequestObjectSigningAlgorithmsSupported indicates an expected call of RequestObjectSigningAlgorithmsSupported.
func (mr *MockConfigurationMockRecorder) RequestObjectSigningAlgorithmsSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestObjectSigningAlgorithmsSupported", reflect.TypeOf((*MockConfiguration)(nil).RequestObjectSigningAlgorithmsSupported))
}

// RequestObjectSupported mocks base method.
func (m *MockConfiguration) RequestObjectSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestObjectSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// RequestObjectSupported indicates an expected call of RequestObjectSupported.
func (mr *MockConfigurationMockRecorder) RequestObjectSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestObjectSupported", reflect.TypeOf((*MockConfiguration)(nil).RequestObjectSupported))
}

// RevocationAuthMethodPrivateKeyJWTSupported mocks base method.
func (m *MockConfiguration) RevocationAuthMethodPrivateKeyJWTSupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevocationAuthMethodPrivateKeyJWTSupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// RevocationAuthMethodPrivateKeyJWTSupported indicates an expected call of RevocationAuthMethodPrivateKeyJWTSupported.
func (mr *MockConfigurationMockRecorder) RevocationAuthMethodPrivateKeyJWTSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevocationAuthMethodPrivateKeyJWTSupported", reflect.TypeOf((*MockConfiguration)(nil).RevocationAuthMethodPrivateKeyJWTSupported))
}

// RevocationEndpoint mocks base method.
func (m *MockConfiguration) RevocationEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevocationEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// RevocationEndpoint indicates an expected call of RevocationEndpoint.
func (mr *MockConfigurationMockRecorder) RevocationEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevocationEndpoint", reflect.TypeOf((*MockConfiguration)(nil).RevocationEndpoint))
}

// RevocationEndpointSigningAlgorithmsSupported mocks base method.
func (m *MockConfiguration) RevocationEndpointSigningAlgorithmsSupported() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevocationEndpointSigningAlgorithmsSupported")
	ret0, _ := ret[0].([]string)
	return ret0
}

// RevocationEndpointSigningAlgorithmsSupported indicates an expected call of RevocationEndpointSigningAlgorithmsSupported.
func (mr *MockConfigurationMockRecorder) RevocationEndpointSigningAlgorithmsSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevocationEndpointSigningAlgorithmsSupported", reflect.TypeOf((*MockConfiguration)(nil).RevocationEndpointSigningAlgorithmsSupported))
}

// SupportedUILocales mocks base method.
func (m *MockConfiguration) SupportedUILocales() []language.Tag {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportedUILocales")
	ret0, _ := ret[0].([]language.Tag)
	return ret0
}

// SupportedUILocales indicates an expected call of SupportedUILocales.
func (mr *MockConfigurationMockRecorder) SupportedUILocales() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportedUILocales", reflect.TypeOf((*MockConfiguration)(nil).SupportedUILocales))
}

// TokenEndpoint mocks base method.
func (m *MockConfiguration) TokenEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// TokenEndpoint indicates an expected call of TokenEndpoint.
func (mr *MockConfigurationMockRecorder) TokenEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenEndpoint", reflect.TypeOf((*MockConfiguration)(nil).TokenEndpoint))
}

// TokenEndpointSigningAlgorithmsSupported mocks base method.
func (m *MockConfiguration) TokenEndpointSigningAlgorithmsSupported() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TokenEndpointSigningAlgorithmsSupported")
	ret0, _ := ret[0].([]string)
	return ret0
}

// TokenEndpointSigningAlgorithmsSupported indicates an expected call of TokenEndpointSigningAlgorithmsSupported.
func (mr *MockConfigurationMockRecorder) TokenEndpointSigningAlgorithmsSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenEndpointSigningAlgorithmsSupported", reflect.TypeOf((*MockConfiguration)(nil).TokenEndpointSigningAlgorithmsSupported))
}

// UserinfoEndpoint mocks base method.
func (m *MockConfiguration) UserinfoEndpoint() *op.Endpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserinfoEndpoint")
	ret0, _ := ret[0].(*op.Endpoint)
	return ret0
}

// UserinfoEndpoint indicates an expected call of UserinfoEndpoint.
func (mr *MockConfigurationMockRecorder) UserinfoEndpoint() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserinfoEndpoint", reflect.TypeOf((*MockConfiguration)(nil).UserinfoEndpoint))
}