auth_config.pb.equal.go

// Code generated by protoc-gen-ext. DO NOT EDIT.
// source: github.com/solo-io/solo-apis/api/gloo/enterprise.gloo/v1/auth_config.proto

package v1

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"strings"

	"github.com/golang/protobuf/proto"
	equality "github.com/solo-io/protoc-gen-ext/pkg/equality"
)

// ensure the imports are used
var (
	_ = errors.New("")
	_ = fmt.Print
	_ = binary.LittleEndian
	_ = bytes.Compare
	_ = strings.Compare
	_ = equality.Equalizer(nil)
	_ = proto.Message(nil)
)

// Equal function
func (m *AuthConfigSpec) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AuthConfigSpec)
	if !ok {
		that2, ok := that.(AuthConfigSpec)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetConfigs()) != len(target.GetConfigs()) {
		return false
	}
	for idx, v := range m.GetConfigs() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetConfigs()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetConfigs()[idx]) {
				return false
			}
		}

	}

	if h, ok := interface{}(m.GetBooleanExpr()).(equality.Equalizer); ok {
		if !h.Equal(target.GetBooleanExpr()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetBooleanExpr(), target.GetBooleanExpr()) {
			return false
		}
	}

	if m.GetFailOnRedirect() != target.GetFailOnRedirect() {
		return false
	}

	return true
}

// Equal function
func (m *ExtAuthExtension) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ExtAuthExtension)
	if !ok {
		that2, ok := that.(ExtAuthExtension)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.Spec.(type) {

	case *ExtAuthExtension_Disable:
		if _, ok := target.Spec.(*ExtAuthExtension_Disable); !ok {
			return false
		}

		if m.GetDisable() != target.GetDisable() {
			return false
		}

	case *ExtAuthExtension_ConfigRef:
		if _, ok := target.Spec.(*ExtAuthExtension_ConfigRef); !ok {
			return false
		}

		if h, ok := interface{}(m.GetConfigRef()).(equality.Equalizer); ok {
			if !h.Equal(target.GetConfigRef()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetConfigRef(), target.GetConfigRef()) {
				return false
			}
		}

	case *ExtAuthExtension_CustomAuth:
		if _, ok := target.Spec.(*ExtAuthExtension_CustomAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetCustomAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetCustomAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetCustomAuth(), target.GetCustomAuth()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Spec != target.Spec {
			return false
		}
	}

	return true
}

// Equal function
func (m *Settings) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*Settings)
	if !ok {
		that2, ok := that.(Settings)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetExtauthzServerRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetExtauthzServerRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetExtauthzServerRef(), target.GetExtauthzServerRef()) {
			return false
		}
	}

	if strings.Compare(m.GetUserIdHeader(), target.GetUserIdHeader()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetRequestTimeout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRequestTimeout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRequestTimeout(), target.GetRequestTimeout()) {
			return false
		}
	}

	if m.GetFailureModeAllow() != target.GetFailureModeAllow() {
		return false
	}

	if h, ok := interface{}(m.GetRequestBody()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRequestBody()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRequestBody(), target.GetRequestBody()) {
			return false
		}
	}

	if m.GetClearRouteCache() != target.GetClearRouteCache() {
		return false
	}

	if m.GetStatusOnError() != target.GetStatusOnError() {
		return false
	}

	if m.GetTransportApiVersion() != target.GetTransportApiVersion() {
		return false
	}

	if strings.Compare(m.GetStatPrefix(), target.GetStatPrefix()) != 0 {
		return false
	}

	switch m.ServiceType.(type) {

	case *Settings_HttpService:
		if _, ok := target.ServiceType.(*Settings_HttpService); !ok {
			return false
		}

		if h, ok := interface{}(m.GetHttpService()).(equality.Equalizer); ok {
			if !h.Equal(target.GetHttpService()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetHttpService(), target.GetHttpService()) {
				return false
			}
		}

	case *Settings_GrpcService:
		if _, ok := target.ServiceType.(*Settings_GrpcService); !ok {
			return false
		}

		if h, ok := interface{}(m.GetGrpcService()).(equality.Equalizer); ok {
			if !h.Equal(target.GetGrpcService()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetGrpcService(), target.GetGrpcService()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.ServiceType != target.ServiceType {
			return false
		}
	}

	return true
}

// Equal function
func (m *GrpcService) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*GrpcService)
	if !ok {
		that2, ok := that.(GrpcService)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetAuthority(), target.GetAuthority()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *HttpService) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HttpService)
	if !ok {
		that2, ok := that.(HttpService)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetPathPrefix(), target.GetPathPrefix()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetRequest()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRequest()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRequest(), target.GetRequest()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetResponse()).(equality.Equalizer); ok {
		if !h.Equal(target.GetResponse()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetResponse(), target.GetResponse()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *BufferSettings) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BufferSettings)
	if !ok {
		that2, ok := that.(BufferSettings)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if m.GetMaxRequestBytes() != target.GetMaxRequestBytes() {
		return false
	}

	if m.GetAllowPartialMessage() != target.GetAllowPartialMessage() {
		return false
	}

	if m.GetPackAsBytes() != target.GetPackAsBytes() {
		return false
	}

	return true
}

// Equal function
func (m *CustomAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*CustomAuth)
	if !ok {
		that2, ok := that.(CustomAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetContextExtensions()) != len(target.GetContextExtensions()) {
		return false
	}
	for k, v := range m.GetContextExtensions() {

		if strings.Compare(v, target.GetContextExtensions()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetName(), target.GetName()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *AuthPlugin) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AuthPlugin)
	if !ok {
		that2, ok := that.(AuthPlugin)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetName(), target.GetName()) != 0 {
		return false
	}

	if strings.Compare(m.GetPluginFileName(), target.GetPluginFileName()) != 0 {
		return false
	}

	if strings.Compare(m.GetExportedSymbolName(), target.GetExportedSymbolName()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetConfig()).(equality.Equalizer); ok {
		if !h.Equal(target.GetConfig()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetConfig(), target.GetConfig()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *BasicAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth)
	if !ok {
		that2, ok := that.(BasicAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetRealm(), target.GetRealm()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetApr()).(equality.Equalizer); ok {
		if !h.Equal(target.GetApr()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetApr(), target.GetApr()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetEncryption()).(equality.Equalizer); ok {
		if !h.Equal(target.GetEncryption()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetEncryption(), target.GetEncryption()) {
			return false
		}
	}

	switch m.UserSource.(type) {

	case *BasicAuth_UserList_:
		if _, ok := target.UserSource.(*BasicAuth_UserList_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetUserList()).(equality.Equalizer); ok {
			if !h.Equal(target.GetUserList()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetUserList(), target.GetUserList()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.UserSource != target.UserSource {
			return false
		}
	}

	return true
}

// Equal function
func (m *HmacAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HmacAuth)
	if !ok {
		that2, ok := that.(HmacAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.SecretStorage.(type) {

	case *HmacAuth_SecretRefs:
		if _, ok := target.SecretStorage.(*HmacAuth_SecretRefs); !ok {
			return false
		}

		if h, ok := interface{}(m.GetSecretRefs()).(equality.Equalizer); ok {
			if !h.Equal(target.GetSecretRefs()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetSecretRefs(), target.GetSecretRefs()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.SecretStorage != target.SecretStorage {
			return false
		}
	}

	switch m.ImplementationType.(type) {

	case *HmacAuth_ParametersInHeaders:
		if _, ok := target.ImplementationType.(*HmacAuth_ParametersInHeaders); !ok {
			return false
		}

		if h, ok := interface{}(m.GetParametersInHeaders()).(equality.Equalizer); ok {
			if !h.Equal(target.GetParametersInHeaders()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetParametersInHeaders(), target.GetParametersInHeaders()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.ImplementationType != target.ImplementationType {
			return false
		}
	}

	return true
}

// Equal function
func (m *SecretRefList) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*SecretRefList)
	if !ok {
		that2, ok := that.(SecretRefList)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetSecretRefs()) != len(target.GetSecretRefs()) {
		return false
	}
	for idx, v := range m.GetSecretRefs() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetSecretRefs()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetSecretRefs()[idx]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *HmacParametersInHeaders) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HmacParametersInHeaders)
	if !ok {
		that2, ok := that.(HmacParametersInHeaders)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *OAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OAuth)
	if !ok {
		that2, ok := that.(OAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClientId(), target.GetClientId()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetClientSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecretRef(), target.GetClientSecretRef()) {
			return false
		}
	}

	if strings.Compare(m.GetIssuerUrl(), target.GetIssuerUrl()) != 0 {
		return false
	}

	if len(m.GetAuthEndpointQueryParams()) != len(target.GetAuthEndpointQueryParams()) {
		return false
	}
	for k, v := range m.GetAuthEndpointQueryParams() {

		if strings.Compare(v, target.GetAuthEndpointQueryParams()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetAppUrl(), target.GetAppUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetCallbackPath(), target.GetCallbackPath()) != 0 {
		return false
	}

	if len(m.GetScopes()) != len(target.GetScopes()) {
		return false
	}
	for idx, v := range m.GetScopes() {

		if strings.Compare(v, target.GetScopes()[idx]) != 0 {
			return false
		}

	}

	return true
}

// Equal function
func (m *OAuth2) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OAuth2)
	if !ok {
		that2, ok := that.(OAuth2)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.OauthType.(type) {

	case *OAuth2_OidcAuthorizationCode:
		if _, ok := target.OauthType.(*OAuth2_OidcAuthorizationCode); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOidcAuthorizationCode()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOidcAuthorizationCode()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOidcAuthorizationCode(), target.GetOidcAuthorizationCode()) {
				return false
			}
		}

	case *OAuth2_AccessTokenValidation:
		if _, ok := target.OauthType.(*OAuth2_AccessTokenValidation); !ok {
			return false
		}

		if h, ok := interface{}(m.GetAccessTokenValidation()).(equality.Equalizer); ok {
			if !h.Equal(target.GetAccessTokenValidation()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetAccessTokenValidation(), target.GetAccessTokenValidation()) {
				return false
			}
		}

	case *OAuth2_Oauth2:
		if _, ok := target.OauthType.(*OAuth2_Oauth2); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOauth2()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOauth2()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOauth2(), target.GetOauth2()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.OauthType != target.OauthType {
			return false
		}
	}

	return true
}

// Equal function
func (m *RedisOptions) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*RedisOptions)
	if !ok {
		that2, ok := that.(RedisOptions)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetHost(), target.GetHost()) != 0 {
		return false
	}

	if m.GetDb() != target.GetDb() {
		return false
	}

	if m.GetPoolSize() != target.GetPoolSize() {
		return false
	}

	if strings.Compare(m.GetTlsCertMountPath(), target.GetTlsCertMountPath()) != 0 {
		return false
	}

	if m.GetSocketType() != target.GetSocketType() {
		return false
	}

	return true
}

// Equal function
func (m *UserSession) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*UserSession)
	if !ok {
		that2, ok := that.(UserSession)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if m.GetFailOnFetchFailure() != target.GetFailOnFetchFailure() {
		return false
	}

	if h, ok := interface{}(m.GetCookieOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetCookieOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetCookieOptions(), target.GetCookieOptions()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetCipherConfig()).(equality.Equalizer); ok {
		if !h.Equal(target.GetCipherConfig()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetCipherConfig(), target.GetCipherConfig()) {
			return false
		}
	}

	switch m.Session.(type) {

	case *UserSession_Cookie:
		if _, ok := target.Session.(*UserSession_Cookie); !ok {
			return false
		}

		if h, ok := interface{}(m.GetCookie()).(equality.Equalizer); ok {
			if !h.Equal(target.GetCookie()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetCookie(), target.GetCookie()) {
				return false
			}
		}

	case *UserSession_Redis:
		if _, ok := target.Session.(*UserSession_Redis); !ok {
			return false
		}

		if h, ok := interface{}(m.GetRedis()).(equality.Equalizer); ok {
			if !h.Equal(target.GetRedis()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetRedis(), target.GetRedis()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Session != target.Session {
			return false
		}
	}

	return true
}

// Equal function
func (m *HeaderConfiguration) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HeaderConfiguration)
	if !ok {
		that2, ok := that.(HeaderConfiguration)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetIdTokenHeader(), target.GetIdTokenHeader()) != 0 {
		return false
	}

	if strings.Compare(m.GetAccessTokenHeader(), target.GetAccessTokenHeader()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetUseBearerSchemaForAuthorization()).(equality.Equalizer); ok {
		if !h.Equal(target.GetUseBearerSchemaForAuthorization()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetUseBearerSchemaForAuthorization(), target.GetUseBearerSchemaForAuthorization()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *DiscoveryOverride) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*DiscoveryOverride)
	if !ok {
		that2, ok := that.(DiscoveryOverride)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetAuthEndpoint(), target.GetAuthEndpoint()) != 0 {
		return false
	}

	if strings.Compare(m.GetTokenEndpoint(), target.GetTokenEndpoint()) != 0 {
		return false
	}

	if strings.Compare(m.GetJwksUri(), target.GetJwksUri()) != 0 {
		return false
	}

	if len(m.GetScopes()) != len(target.GetScopes()) {
		return false
	}
	for idx, v := range m.GetScopes() {

		if strings.Compare(v, target.GetScopes()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetResponseTypes()) != len(target.GetResponseTypes()) {
		return false
	}
	for idx, v := range m.GetResponseTypes() {

		if strings.Compare(v, target.GetResponseTypes()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetSubjects()) != len(target.GetSubjects()) {
		return false
	}
	for idx, v := range m.GetSubjects() {

		if strings.Compare(v, target.GetSubjects()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetIdTokenAlgs()) != len(target.GetIdTokenAlgs()) {
		return false
	}
	for idx, v := range m.GetIdTokenAlgs() {

		if strings.Compare(v, target.GetIdTokenAlgs()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetAuthMethods()) != len(target.GetAuthMethods()) {
		return false
	}
	for idx, v := range m.GetAuthMethods() {

		if strings.Compare(v, target.GetAuthMethods()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetClaims()) != len(target.GetClaims()) {
		return false
	}
	for idx, v := range m.GetClaims() {

		if strings.Compare(v, target.GetClaims()[idx]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetRevocationEndpoint(), target.GetRevocationEndpoint()) != 0 {
		return false
	}

	if strings.Compare(m.GetEndSessionEndpoint(), target.GetEndSessionEndpoint()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *JwksOnDemandCacheRefreshPolicy) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*JwksOnDemandCacheRefreshPolicy)
	if !ok {
		that2, ok := that.(JwksOnDemandCacheRefreshPolicy)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.Policy.(type) {

	case *JwksOnDemandCacheRefreshPolicy_Never:
		if _, ok := target.Policy.(*JwksOnDemandCacheRefreshPolicy_Never); !ok {
			return false
		}

		if h, ok := interface{}(m.GetNever()).(equality.Equalizer); ok {
			if !h.Equal(target.GetNever()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetNever(), target.GetNever()) {
				return false
			}
		}

	case *JwksOnDemandCacheRefreshPolicy_Always:
		if _, ok := target.Policy.(*JwksOnDemandCacheRefreshPolicy_Always); !ok {
			return false
		}

		if h, ok := interface{}(m.GetAlways()).(equality.Equalizer); ok {
			if !h.Equal(target.GetAlways()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetAlways(), target.GetAlways()) {
				return false
			}
		}

	case *JwksOnDemandCacheRefreshPolicy_MaxIdpReqPerPollingInterval:
		if _, ok := target.Policy.(*JwksOnDemandCacheRefreshPolicy_MaxIdpReqPerPollingInterval); !ok {
			return false
		}

		if m.GetMaxIdpReqPerPollingInterval() != target.GetMaxIdpReqPerPollingInterval() {
			return false
		}

	default:
		// m is nil but target is not nil
		if m.Policy != target.Policy {
			return false
		}
	}

	return true
}

// Equal function
func (m *AutoMapFromMetadata) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AutoMapFromMetadata)
	if !ok {
		that2, ok := that.(AutoMapFromMetadata)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetNamespace(), target.GetNamespace()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *EndSessionProperties) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*EndSessionProperties)
	if !ok {
		that2, ok := that.(EndSessionProperties)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if m.GetMethodType() != target.GetMethodType() {
		return false
	}

	return true
}

// Equal function
func (m *ClaimToHeader) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ClaimToHeader)
	if !ok {
		that2, ok := that.(ClaimToHeader)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClaim(), target.GetClaim()) != 0 {
		return false
	}

	if strings.Compare(m.GetHeader(), target.GetHeader()) != 0 {
		return false
	}

	if m.GetAppend() != target.GetAppend() {
		return false
	}

	return true
}

// Equal function
func (m *Azure) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*Azure)
	if !ok {
		that2, ok := that.(Azure)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClientId(), target.GetClientId()) != 0 {
		return false
	}

	if strings.Compare(m.GetTenantId(), target.GetTenantId()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetClientSecret()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecret()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecret(), target.GetClientSecret()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetClaimsCachingOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClaimsCachingOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClaimsCachingOptions(), target.GetClaimsCachingOptions()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClientId(), target.GetClientId()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetClientSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecretRef(), target.GetClientSecretRef()) {
			return false
		}
	}

	if strings.Compare(m.GetIssuerUrl(), target.GetIssuerUrl()) != 0 {
		return false
	}

	if len(m.GetAuthEndpointQueryParams()) != len(target.GetAuthEndpointQueryParams()) {
		return false
	}
	for k, v := range m.GetAuthEndpointQueryParams() {

		if strings.Compare(v, target.GetAuthEndpointQueryParams()[k]) != 0 {
			return false
		}

	}

	if len(m.GetTokenEndpointQueryParams()) != len(target.GetTokenEndpointQueryParams()) {
		return false
	}
	for k, v := range m.GetTokenEndpointQueryParams() {

		if strings.Compare(v, target.GetTokenEndpointQueryParams()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetAppUrl(), target.GetAppUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetCallbackPath(), target.GetCallbackPath()) != 0 {
		return false
	}

	if strings.Compare(m.GetLogoutPath(), target.GetLogoutPath()) != 0 {
		return false
	}

	if strings.Compare(m.GetAfterLogoutUrl(), target.GetAfterLogoutUrl()) != 0 {
		return false
	}

	if len(m.GetScopes()) != len(target.GetScopes()) {
		return false
	}
	for idx, v := range m.GetScopes() {

		if strings.Compare(v, target.GetScopes()[idx]) != 0 {
			return false
		}

	}

	if h, ok := interface{}(m.GetSession()).(equality.Equalizer); ok {
		if !h.Equal(target.GetSession()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetSession(), target.GetSession()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetHeaders()).(equality.Equalizer); ok {
		if !h.Equal(target.GetHeaders()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetHeaders(), target.GetHeaders()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetDiscoveryOverride()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDiscoveryOverride()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDiscoveryOverride(), target.GetDiscoveryOverride()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetDiscoveryPollInterval()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDiscoveryPollInterval()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDiscoveryPollInterval(), target.GetDiscoveryPollInterval()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetJwksCacheRefreshPolicy()).(equality.Equalizer); ok {
		if !h.Equal(target.GetJwksCacheRefreshPolicy()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetJwksCacheRefreshPolicy(), target.GetJwksCacheRefreshPolicy()) {
			return false
		}
	}

	if strings.Compare(m.GetSessionIdHeaderName(), target.GetSessionIdHeaderName()) != 0 {
		return false
	}

	if m.GetParseCallbackPathAsRegex() != target.GetParseCallbackPathAsRegex() {
		return false
	}

	if h, ok := interface{}(m.GetAutoMapFromMetadata()).(equality.Equalizer); ok {
		if !h.Equal(target.GetAutoMapFromMetadata()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetAutoMapFromMetadata(), target.GetAutoMapFromMetadata()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetEndSessionProperties()).(equality.Equalizer); ok {
		if !h.Equal(target.GetEndSessionProperties()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetEndSessionProperties(), target.GetEndSessionProperties()) {
			return false
		}
	}

	if len(m.GetDynamicMetadataFromClaims()) != len(target.GetDynamicMetadataFromClaims()) {
		return false
	}
	for k, v := range m.GetDynamicMetadataFromClaims() {

		if strings.Compare(v, target.GetDynamicMetadataFromClaims()[k]) != 0 {
			return false
		}

	}

	if h, ok := interface{}(m.GetDisableClientSecret()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDisableClientSecret()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDisableClientSecret(), target.GetDisableClientSecret()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetAccessToken()).(equality.Equalizer); ok {
		if !h.Equal(target.GetAccessToken()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetAccessToken(), target.GetAccessToken()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetIdentityToken()).(equality.Equalizer); ok {
		if !h.Equal(target.GetIdentityToken()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetIdentityToken(), target.GetIdentityToken()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetClientAuthentication()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientAuthentication()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientAuthentication(), target.GetClientAuthentication()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetFrontChannelLogout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetFrontChannelLogout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetFrontChannelLogout(), target.GetFrontChannelLogout()) {
			return false
		}
	}

	switch m.Provider.(type) {

	case *OidcAuthorizationCode_Default_:
		if _, ok := target.Provider.(*OidcAuthorizationCode_Default_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetDefault()).(equality.Equalizer); ok {
			if !h.Equal(target.GetDefault()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetDefault(), target.GetDefault()) {
				return false
			}
		}

	case *OidcAuthorizationCode_Azure:
		if _, ok := target.Provider.(*OidcAuthorizationCode_Azure); !ok {
			return false
		}

		if h, ok := interface{}(m.GetAzure()).(equality.Equalizer); ok {
			if !h.Equal(target.GetAzure()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetAzure(), target.GetAzure()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Provider != target.Provider {
			return false
		}
	}

	return true
}

// Equal function
func (m *PlainOAuth2) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PlainOAuth2)
	if !ok {
		that2, ok := that.(PlainOAuth2)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClientId(), target.GetClientId()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetClientSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecretRef(), target.GetClientSecretRef()) {
			return false
		}
	}

	if len(m.GetAuthEndpointQueryParams()) != len(target.GetAuthEndpointQueryParams()) {
		return false
	}
	for k, v := range m.GetAuthEndpointQueryParams() {

		if strings.Compare(v, target.GetAuthEndpointQueryParams()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetAppUrl(), target.GetAppUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetCallbackPath(), target.GetCallbackPath()) != 0 {
		return false
	}

	if len(m.GetScopes()) != len(target.GetScopes()) {
		return false
	}
	for idx, v := range m.GetScopes() {

		if strings.Compare(v, target.GetScopes()[idx]) != 0 {
			return false
		}

	}

	if h, ok := interface{}(m.GetSession()).(equality.Equalizer); ok {
		if !h.Equal(target.GetSession()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetSession(), target.GetSession()) {
			return false
		}
	}

	if strings.Compare(m.GetLogoutPath(), target.GetLogoutPath()) != 0 {
		return false
	}

	if len(m.GetTokenEndpointQueryParams()) != len(target.GetTokenEndpointQueryParams()) {
		return false
	}
	for k, v := range m.GetTokenEndpointQueryParams() {

		if strings.Compare(v, target.GetTokenEndpointQueryParams()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetAfterLogoutUrl(), target.GetAfterLogoutUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetAuthEndpoint(), target.GetAuthEndpoint()) != 0 {
		return false
	}

	if strings.Compare(m.GetTokenEndpoint(), target.GetTokenEndpoint()) != 0 {
		return false
	}

	if strings.Compare(m.GetRevocationEndpoint(), target.GetRevocationEndpoint()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetDisableClientSecret()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDisableClientSecret()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDisableClientSecret(), target.GetDisableClientSecret()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *JwtValidation) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*JwtValidation)
	if !ok {
		that2, ok := that.(JwtValidation)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetIssuer(), target.GetIssuer()) != 0 {
		return false
	}

	switch m.JwksSourceSpecifier.(type) {

	case *JwtValidation_RemoteJwks_:
		if _, ok := target.JwksSourceSpecifier.(*JwtValidation_RemoteJwks_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetRemoteJwks()).(equality.Equalizer); ok {
			if !h.Equal(target.GetRemoteJwks()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetRemoteJwks(), target.GetRemoteJwks()) {
				return false
			}
		}

	case *JwtValidation_LocalJwks_:
		if _, ok := target.JwksSourceSpecifier.(*JwtValidation_LocalJwks_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetLocalJwks()).(equality.Equalizer); ok {
			if !h.Equal(target.GetLocalJwks()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetLocalJwks(), target.GetLocalJwks()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.JwksSourceSpecifier != target.JwksSourceSpecifier {
			return false
		}
	}

	return true
}

// Equal function
func (m *IntrospectionValidation) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*IntrospectionValidation)
	if !ok {
		that2, ok := that.(IntrospectionValidation)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetIntrospectionUrl(), target.GetIntrospectionUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetClientId(), target.GetClientId()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetClientSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecretRef(), target.GetClientSecretRef()) {
			return false
		}
	}

	if strings.Compare(m.GetUserIdAttributeName(), target.GetUserIdAttributeName()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetDisableClientSecret()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDisableClientSecret()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDisableClientSecret(), target.GetDisableClientSecret()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *AccessTokenValidation) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AccessTokenValidation)
	if !ok {
		that2, ok := that.(AccessTokenValidation)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetUserinfoUrl(), target.GetUserinfoUrl()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetCacheTimeout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetCacheTimeout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetCacheTimeout(), target.GetCacheTimeout()) {
			return false
		}
	}

	if len(m.GetDynamicMetadataFromClaims()) != len(target.GetDynamicMetadataFromClaims()) {
		return false
	}
	for k, v := range m.GetDynamicMetadataFromClaims() {

		if strings.Compare(v, target.GetDynamicMetadataFromClaims()[k]) != 0 {
			return false
		}

	}

	if len(m.GetClaimsToHeaders()) != len(target.GetClaimsToHeaders()) {
		return false
	}
	for idx, v := range m.GetClaimsToHeaders() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetClaimsToHeaders()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetClaimsToHeaders()[idx]) {
				return false
			}
		}

	}

	switch m.ValidationType.(type) {

	case *AccessTokenValidation_IntrospectionUrl:
		if _, ok := target.ValidationType.(*AccessTokenValidation_IntrospectionUrl); !ok {
			return false
		}

		if strings.Compare(m.GetIntrospectionUrl(), target.GetIntrospectionUrl()) != 0 {
			return false
		}

	case *AccessTokenValidation_Jwt:
		if _, ok := target.ValidationType.(*AccessTokenValidation_Jwt); !ok {
			return false
		}

		if h, ok := interface{}(m.GetJwt()).(equality.Equalizer); ok {
			if !h.Equal(target.GetJwt()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetJwt(), target.GetJwt()) {
				return false
			}
		}

	case *AccessTokenValidation_Introspection:
		if _, ok := target.ValidationType.(*AccessTokenValidation_Introspection); !ok {
			return false
		}

		if h, ok := interface{}(m.GetIntrospection()).(equality.Equalizer); ok {
			if !h.Equal(target.GetIntrospection()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetIntrospection(), target.GetIntrospection()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.ValidationType != target.ValidationType {
			return false
		}
	}

	switch m.ScopeValidation.(type) {

	case *AccessTokenValidation_RequiredScopes:
		if _, ok := target.ScopeValidation.(*AccessTokenValidation_RequiredScopes); !ok {
			return false
		}

		if h, ok := interface{}(m.GetRequiredScopes()).(equality.Equalizer); ok {
			if !h.Equal(target.GetRequiredScopes()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetRequiredScopes(), target.GetRequiredScopes()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.ScopeValidation != target.ScopeValidation {
			return false
		}
	}

	switch m.Provider.(type) {

	case *AccessTokenValidation_Default_:
		if _, ok := target.Provider.(*AccessTokenValidation_Default_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetDefault()).(equality.Equalizer); ok {
			if !h.Equal(target.GetDefault()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetDefault(), target.GetDefault()) {
				return false
			}
		}

	case *AccessTokenValidation_Azure:
		if _, ok := target.Provider.(*AccessTokenValidation_Azure); !ok {
			return false
		}

		if h, ok := interface{}(m.GetAzure()).(equality.Equalizer); ok {
			if !h.Equal(target.GetAzure()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetAzure(), target.GetAzure()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Provider != target.Provider {
			return false
		}
	}

	return true
}

// Equal function
func (m *OauthSecret) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OauthSecret)
	if !ok {
		that2, ok := that.(OauthSecret)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetClientSecret(), target.GetClientSecret()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *ApiKeyAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ApiKeyAuth)
	if !ok {
		that2, ok := that.(ApiKeyAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetLabelSelector()) != len(target.GetLabelSelector()) {
		return false
	}
	for k, v := range m.GetLabelSelector() {

		if strings.Compare(v, target.GetLabelSelector()[k]) != 0 {
			return false
		}

	}

	if len(m.GetApiKeySecretRefs()) != len(target.GetApiKeySecretRefs()) {
		return false
	}
	for idx, v := range m.GetApiKeySecretRefs() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetApiKeySecretRefs()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetApiKeySecretRefs()[idx]) {
				return false
			}
		}

	}

	if strings.Compare(m.GetHeaderName(), target.GetHeaderName()) != 0 {
		return false
	}

	if len(m.GetHeadersFromMetadata()) != len(target.GetHeadersFromMetadata()) {
		return false
	}
	for k, v := range m.GetHeadersFromMetadata() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetHeadersFromMetadata()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetHeadersFromMetadata()[k]) {
				return false
			}
		}

	}

	if len(m.GetHeadersFromMetadataEntry()) != len(target.GetHeadersFromMetadataEntry()) {
		return false
	}
	for k, v := range m.GetHeadersFromMetadataEntry() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetHeadersFromMetadataEntry()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetHeadersFromMetadataEntry()[k]) {
				return false
			}
		}

	}

	if m.GetSkipMetadataValidation() != target.GetSkipMetadataValidation() {
		return false
	}

	switch m.StorageBackend.(type) {

	case *ApiKeyAuth_K8SSecretApikeyStorage:
		if _, ok := target.StorageBackend.(*ApiKeyAuth_K8SSecretApikeyStorage); !ok {
			return false
		}

		if h, ok := interface{}(m.GetK8SSecretApikeyStorage()).(equality.Equalizer); ok {
			if !h.Equal(target.GetK8SSecretApikeyStorage()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetK8SSecretApikeyStorage(), target.GetK8SSecretApikeyStorage()) {
				return false
			}
		}

	case *ApiKeyAuth_AerospikeApikeyStorage:
		if _, ok := target.StorageBackend.(*ApiKeyAuth_AerospikeApikeyStorage); !ok {
			return false
		}

		if h, ok := interface{}(m.GetAerospikeApikeyStorage()).(equality.Equalizer); ok {
			if !h.Equal(target.GetAerospikeApikeyStorage()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetAerospikeApikeyStorage(), target.GetAerospikeApikeyStorage()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.StorageBackend != target.StorageBackend {
			return false
		}
	}

	return true
}

// Equal function
func (m *K8SSecretApiKeyStorage) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*K8SSecretApiKeyStorage)
	if !ok {
		that2, ok := that.(K8SSecretApiKeyStorage)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetLabelSelector()) != len(target.GetLabelSelector()) {
		return false
	}
	for k, v := range m.GetLabelSelector() {

		if strings.Compare(v, target.GetLabelSelector()[k]) != 0 {
			return false
		}

	}

	if len(m.GetApiKeySecretRefs()) != len(target.GetApiKeySecretRefs()) {
		return false
	}
	for idx, v := range m.GetApiKeySecretRefs() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetApiKeySecretRefs()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetApiKeySecretRefs()[idx]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *AerospikeApiKeyStorage) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AerospikeApiKeyStorage)
	if !ok {
		that2, ok := that.(AerospikeApiKeyStorage)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetHostname(), target.GetHostname()) != 0 {
		return false
	}

	if strings.Compare(m.GetNamespace(), target.GetNamespace()) != 0 {
		return false
	}

	if strings.Compare(m.GetSet(), target.GetSet()) != 0 {
		return false
	}

	if m.GetPort() != target.GetPort() {
		return false
	}

	if m.GetBatchSize() != target.GetBatchSize() {
		return false
	}

	if h, ok := interface{}(m.GetReadModeSc()).(equality.Equalizer); ok {
		if !h.Equal(target.GetReadModeSc()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetReadModeSc(), target.GetReadModeSc()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetReadModeAp()).(equality.Equalizer); ok {
		if !h.Equal(target.GetReadModeAp()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetReadModeAp(), target.GetReadModeAp()) {
			return false
		}
	}

	if strings.Compare(m.GetNodeTlsName(), target.GetNodeTlsName()) != 0 {
		return false
	}

	if strings.Compare(m.GetCertPath(), target.GetCertPath()) != 0 {
		return false
	}

	if strings.Compare(m.GetKeyPath(), target.GetKeyPath()) != 0 {
		return false
	}

	if m.GetAllowInsecure() != target.GetAllowInsecure() {
		return false
	}

	if strings.Compare(m.GetRootCaPath(), target.GetRootCaPath()) != 0 {
		return false
	}

	if strings.Compare(m.GetTlsVersion(), target.GetTlsVersion()) != 0 {
		return false
	}

	if len(m.GetTlsCurveGroups()) != len(target.GetTlsCurveGroups()) {
		return false
	}
	for idx, v := range m.GetTlsCurveGroups() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetTlsCurveGroups()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetTlsCurveGroups()[idx]) {
				return false
			}
		}

	}

	if len(m.GetLabelSelector()) != len(target.GetLabelSelector()) {
		return false
	}
	for k, v := range m.GetLabelSelector() {

		if strings.Compare(v, target.GetLabelSelector()[k]) != 0 {
			return false
		}

	}

	switch m.CommitLevel.(type) {

	case *AerospikeApiKeyStorage_CommitAll:
		if _, ok := target.CommitLevel.(*AerospikeApiKeyStorage_CommitAll); !ok {
			return false
		}

		if m.GetCommitAll() != target.GetCommitAll() {
			return false
		}

	case *AerospikeApiKeyStorage_CommitMaster:
		if _, ok := target.CommitLevel.(*AerospikeApiKeyStorage_CommitMaster); !ok {
			return false
		}

		if m.GetCommitMaster() != target.GetCommitMaster() {
			return false
		}

	default:
		// m is nil but target is not nil
		if m.CommitLevel != target.CommitLevel {
			return false
		}
	}

	return true
}

// Equal function
func (m *ServerDefaultApiKeyStorage) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ServerDefaultApiKeyStorage)
	if !ok {
		that2, ok := that.(ServerDefaultApiKeyStorage)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *ApiKey) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ApiKey)
	if !ok {
		that2, ok := that.(ApiKey)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetApiKey(), target.GetApiKey()) != 0 {
		return false
	}

	if len(m.GetLabels()) != len(target.GetLabels()) {
		return false
	}
	for idx, v := range m.GetLabels() {

		if strings.Compare(v, target.GetLabels()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetMetadata()) != len(target.GetMetadata()) {
		return false
	}
	for k, v := range m.GetMetadata() {

		if strings.Compare(v, target.GetMetadata()[k]) != 0 {
			return false
		}

	}

	if strings.Compare(m.GetUuid(), target.GetUuid()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *ApiKeySecret) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ApiKeySecret)
	if !ok {
		that2, ok := that.(ApiKeySecret)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetApiKey(), target.GetApiKey()) != 0 {
		return false
	}

	if len(m.GetLabels()) != len(target.GetLabels()) {
		return false
	}
	for idx, v := range m.GetLabels() {

		if strings.Compare(v, target.GetLabels()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetMetadata()) != len(target.GetMetadata()) {
		return false
	}
	for k, v := range m.GetMetadata() {

		if strings.Compare(v, target.GetMetadata()[k]) != 0 {
			return false
		}

	}

	return true
}

// Equal function
func (m *OpaAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OpaAuth)
	if !ok {
		that2, ok := that.(OpaAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetModules()) != len(target.GetModules()) {
		return false
	}
	for idx, v := range m.GetModules() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetModules()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetModules()[idx]) {
				return false
			}
		}

	}

	if strings.Compare(m.GetQuery(), target.GetQuery()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetOptions(), target.GetOptions()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *OpaAuthOptions) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OpaAuthOptions)
	if !ok {
		that2, ok := that.(OpaAuthOptions)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if m.GetFastInputConversion() != target.GetFastInputConversion() {
		return false
	}

	if m.GetReturnDecisionReason() != target.GetReturnDecisionReason() {
		return false
	}

	return true
}

// Equal function
func (m *OpaServerAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OpaServerAuth)
	if !ok {
		that2, ok := that.(OpaServerAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetPackage(), target.GetPackage()) != 0 {
		return false
	}

	if strings.Compare(m.GetRuleName(), target.GetRuleName()) != 0 {
		return false
	}

	if strings.Compare(m.GetServerAddr(), target.GetServerAddr()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetOptions(), target.GetOptions()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *Ldap) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*Ldap)
	if !ok {
		that2, ok := that.(Ldap)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetAddress(), target.GetAddress()) != 0 {
		return false
	}

	if strings.Compare(m.GetUserDnTemplate(), target.GetUserDnTemplate()) != 0 {
		return false
	}

	if strings.Compare(m.GetMembershipAttributeName(), target.GetMembershipAttributeName()) != 0 {
		return false
	}

	if len(m.GetAllowedGroups()) != len(target.GetAllowedGroups()) {
		return false
	}
	for idx, v := range m.GetAllowedGroups() {

		if strings.Compare(v, target.GetAllowedGroups()[idx]) != 0 {
			return false
		}

	}

	if h, ok := interface{}(m.GetPool()).(equality.Equalizer); ok {
		if !h.Equal(target.GetPool()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetPool(), target.GetPool()) {
			return false
		}
	}

	if strings.Compare(m.GetSearchFilter(), target.GetSearchFilter()) != 0 {
		return false
	}

	if m.GetDisableGroupChecking() != target.GetDisableGroupChecking() {
		return false
	}

	if h, ok := interface{}(m.GetGroupLookupSettings()).(equality.Equalizer); ok {
		if !h.Equal(target.GetGroupLookupSettings()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetGroupLookupSettings(), target.GetGroupLookupSettings()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *LdapServiceAccount) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*LdapServiceAccount)
	if !ok {
		that2, ok := that.(LdapServiceAccount)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetCredentialsSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetCredentialsSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetCredentialsSecretRef(), target.GetCredentialsSecretRef()) {
			return false
		}
	}

	if m.GetCheckGroupsWithServiceAccount() != target.GetCheckGroupsWithServiceAccount() {
		return false
	}

	return true
}

// Equal function
func (m *PassThroughAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughAuth)
	if !ok {
		that2, ok := that.(PassThroughAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetConfig()).(equality.Equalizer); ok {
		if !h.Equal(target.GetConfig()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetConfig(), target.GetConfig()) {
			return false
		}
	}

	if m.GetFailureModeAllow() != target.GetFailureModeAllow() {
		return false
	}

	switch m.Protocol.(type) {

	case *PassThroughAuth_Grpc:
		if _, ok := target.Protocol.(*PassThroughAuth_Grpc); !ok {
			return false
		}

		if h, ok := interface{}(m.GetGrpc()).(equality.Equalizer); ok {
			if !h.Equal(target.GetGrpc()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetGrpc(), target.GetGrpc()) {
				return false
			}
		}

	case *PassThroughAuth_Http:
		if _, ok := target.Protocol.(*PassThroughAuth_Http); !ok {
			return false
		}

		if h, ok := interface{}(m.GetHttp()).(equality.Equalizer); ok {
			if !h.Equal(target.GetHttp()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetHttp(), target.GetHttp()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Protocol != target.Protocol {
			return false
		}
	}

	return true
}

// Equal function
func (m *BackoffStrategy) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BackoffStrategy)
	if !ok {
		that2, ok := that.(BackoffStrategy)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetBaseInterval()).(equality.Equalizer); ok {
		if !h.Equal(target.GetBaseInterval()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetBaseInterval(), target.GetBaseInterval()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetMaxInterval()).(equality.Equalizer); ok {
		if !h.Equal(target.GetMaxInterval()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetMaxInterval(), target.GetMaxInterval()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *RetryPolicy) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*RetryPolicy)
	if !ok {
		that2, ok := that.(RetryPolicy)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetNumRetries()).(equality.Equalizer); ok {
		if !h.Equal(target.GetNumRetries()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetNumRetries(), target.GetNumRetries()) {
			return false
		}
	}

	switch m.Strategy.(type) {

	case *RetryPolicy_RetryBackOff:
		if _, ok := target.Strategy.(*RetryPolicy_RetryBackOff); !ok {
			return false
		}

		if h, ok := interface{}(m.GetRetryBackOff()).(equality.Equalizer); ok {
			if !h.Equal(target.GetRetryBackOff()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetRetryBackOff(), target.GetRetryBackOff()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Strategy != target.Strategy {
			return false
		}
	}

	return true
}

// Equal function
func (m *PassThroughGrpc) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughGrpc)
	if !ok {
		that2, ok := that.(PassThroughGrpc)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetAddress(), target.GetAddress()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetConnectionTimeout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetConnectionTimeout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetConnectionTimeout(), target.GetConnectionTimeout()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetTlsConfig()).(equality.Equalizer); ok {
		if !h.Equal(target.GetTlsConfig()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetTlsConfig(), target.GetTlsConfig()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetRetryPolicy()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRetryPolicy()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRetryPolicy(), target.GetRetryPolicy()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *PassThroughGrpcTLSConfig) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughGrpcTLSConfig)
	if !ok {
		that2, ok := that.(PassThroughGrpcTLSConfig)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *PassThroughHttp) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughHttp)
	if !ok {
		that2, ok := that.(PassThroughHttp)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetUrl(), target.GetUrl()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetRequest()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRequest()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRequest(), target.GetRequest()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetResponse()).(equality.Equalizer); ok {
		if !h.Equal(target.GetResponse()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetResponse(), target.GetResponse()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetConnectionTimeout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetConnectionTimeout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetConnectionTimeout(), target.GetConnectionTimeout()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *PortalAuth) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PortalAuth)
	if !ok {
		that2, ok := that.(PortalAuth)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetUrl(), target.GetUrl()) != 0 {
		return false
	}

	if strings.Compare(m.GetApiKeyHeader(), target.GetApiKeyHeader()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetRedisOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRedisOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRedisOptions(), target.GetRedisOptions()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetCacheDuration()).(equality.Equalizer); ok {
		if !h.Equal(target.GetCacheDuration()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetCacheDuration(), target.GetCacheDuration()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetRequestTimeout()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRequestTimeout()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRequestTimeout(), target.GetRequestTimeout()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *AuthConfigStatus) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AuthConfigStatus)
	if !ok {
		that2, ok := that.(AuthConfigStatus)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if m.GetState() != target.GetState() {
		return false
	}

	if strings.Compare(m.GetReason(), target.GetReason()) != 0 {
		return false
	}

	if strings.Compare(m.GetReportedBy(), target.GetReportedBy()) != 0 {
		return false
	}

	if len(m.GetSubresourceStatuses()) != len(target.GetSubresourceStatuses()) {
		return false
	}
	for k, v := range m.GetSubresourceStatuses() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetSubresourceStatuses()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetSubresourceStatuses()[k]) {
				return false
			}
		}

	}

	if h, ok := interface{}(m.GetDetails()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDetails()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDetails(), target.GetDetails()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *AuthConfigNamespacedStatuses) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AuthConfigNamespacedStatuses)
	if !ok {
		that2, ok := that.(AuthConfigNamespacedStatuses)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetStatuses()) != len(target.GetStatuses()) {
		return false
	}
	for k, v := range m.GetStatuses() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetStatuses()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetStatuses()[k]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *AuthConfigSpec_Config) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AuthConfigSpec_Config)
	if !ok {
		that2, ok := that.(AuthConfigSpec_Config)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetName()).(equality.Equalizer); ok {
		if !h.Equal(target.GetName()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetName(), target.GetName()) {
			return false
		}
	}

	switch m.AuthConfig.(type) {

	case *AuthConfigSpec_Config_BasicAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_BasicAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetBasicAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetBasicAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetBasicAuth(), target.GetBasicAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_Oauth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_Oauth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOauth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOauth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOauth(), target.GetOauth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_Oauth2:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_Oauth2); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOauth2()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOauth2()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOauth2(), target.GetOauth2()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_ApiKeyAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_ApiKeyAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetApiKeyAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetApiKeyAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetApiKeyAuth(), target.GetApiKeyAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_PluginAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_PluginAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetPluginAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetPluginAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetPluginAuth(), target.GetPluginAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_OpaAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_OpaAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOpaAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOpaAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOpaAuth(), target.GetOpaAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_Ldap:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_Ldap); !ok {
			return false
		}

		if h, ok := interface{}(m.GetLdap()).(equality.Equalizer); ok {
			if !h.Equal(target.GetLdap()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetLdap(), target.GetLdap()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_Jwt:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_Jwt); !ok {
			return false
		}

		if h, ok := interface{}(m.GetJwt()).(equality.Equalizer); ok {
			if !h.Equal(target.GetJwt()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetJwt(), target.GetJwt()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_PassThroughAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_PassThroughAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetPassThroughAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetPassThroughAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetPassThroughAuth(), target.GetPassThroughAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_HmacAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_HmacAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetHmacAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetHmacAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetHmacAuth(), target.GetHmacAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_OpaServerAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_OpaServerAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetOpaServerAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetOpaServerAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetOpaServerAuth(), target.GetOpaServerAuth()) {
				return false
			}
		}

	case *AuthConfigSpec_Config_PortalAuth:
		if _, ok := target.AuthConfig.(*AuthConfigSpec_Config_PortalAuth); !ok {
			return false
		}

		if h, ok := interface{}(m.GetPortalAuth()).(equality.Equalizer); ok {
			if !h.Equal(target.GetPortalAuth()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetPortalAuth(), target.GetPortalAuth()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.AuthConfig != target.AuthConfig {
			return false
		}
	}

	return true
}

// Equal function
func (m *HttpService_Request) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HttpService_Request)
	if !ok {
		that2, ok := that.(HttpService_Request)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetAllowedHeaders()) != len(target.GetAllowedHeaders()) {
		return false
	}
	for idx, v := range m.GetAllowedHeaders() {

		if strings.Compare(v, target.GetAllowedHeaders()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetHeadersToAdd()) != len(target.GetHeadersToAdd()) {
		return false
	}
	for k, v := range m.GetHeadersToAdd() {

		if strings.Compare(v, target.GetHeadersToAdd()[k]) != 0 {
			return false
		}

	}

	if len(m.GetAllowedHeadersRegex()) != len(target.GetAllowedHeadersRegex()) {
		return false
	}
	for idx, v := range m.GetAllowedHeadersRegex() {

		if strings.Compare(v, target.GetAllowedHeadersRegex()[idx]) != 0 {
			return false
		}

	}

	return true
}

// Equal function
func (m *HttpService_Response) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*HttpService_Response)
	if !ok {
		that2, ok := that.(HttpService_Response)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetAllowedUpstreamHeaders()) != len(target.GetAllowedUpstreamHeaders()) {
		return false
	}
	for idx, v := range m.GetAllowedUpstreamHeaders() {

		if strings.Compare(v, target.GetAllowedUpstreamHeaders()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetAllowedClientHeaders()) != len(target.GetAllowedClientHeaders()) {
		return false
	}
	for idx, v := range m.GetAllowedClientHeaders() {

		if strings.Compare(v, target.GetAllowedClientHeaders()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetAllowedUpstreamHeadersToAppend()) != len(target.GetAllowedUpstreamHeadersToAppend()) {
		return false
	}
	for idx, v := range m.GetAllowedUpstreamHeadersToAppend() {

		if strings.Compare(v, target.GetAllowedUpstreamHeadersToAppend()[idx]) != 0 {
			return false
		}

	}

	return true
}

// Equal function
func (m *BasicAuth_Apr) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_Apr)
	if !ok {
		that2, ok := that.(BasicAuth_Apr)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetUsers()) != len(target.GetUsers()) {
		return false
	}
	for k, v := range m.GetUsers() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetUsers()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetUsers()[k]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *BasicAuth_EncryptionType) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_EncryptionType)
	if !ok {
		that2, ok := that.(BasicAuth_EncryptionType)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.Algorithm.(type) {

	case *BasicAuth_EncryptionType_Apr_:
		if _, ok := target.Algorithm.(*BasicAuth_EncryptionType_Apr_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetApr()).(equality.Equalizer); ok {
			if !h.Equal(target.GetApr()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetApr(), target.GetApr()) {
				return false
			}
		}

	case *BasicAuth_EncryptionType_Sha1_:
		if _, ok := target.Algorithm.(*BasicAuth_EncryptionType_Sha1_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetSha1()).(equality.Equalizer); ok {
			if !h.Equal(target.GetSha1()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetSha1(), target.GetSha1()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Algorithm != target.Algorithm {
			return false
		}
	}

	return true
}

// Equal function
func (m *BasicAuth_User) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_User)
	if !ok {
		that2, ok := that.(BasicAuth_User)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetSalt(), target.GetSalt()) != 0 {
		return false
	}

	if strings.Compare(m.GetHashedPassword(), target.GetHashedPassword()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *BasicAuth_UserList) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_UserList)
	if !ok {
		that2, ok := that.(BasicAuth_UserList)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetUsers()) != len(target.GetUsers()) {
		return false
	}
	for k, v := range m.GetUsers() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetUsers()[k]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetUsers()[k]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *BasicAuth_Apr_SaltedHashedPassword) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_Apr_SaltedHashedPassword)
	if !ok {
		that2, ok := that.(BasicAuth_Apr_SaltedHashedPassword)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetSalt(), target.GetSalt()) != 0 {
		return false
	}

	if strings.Compare(m.GetHashedPassword(), target.GetHashedPassword()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *BasicAuth_EncryptionType_Sha1) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_EncryptionType_Sha1)
	if !ok {
		that2, ok := that.(BasicAuth_EncryptionType_Sha1)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *BasicAuth_EncryptionType_Apr) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*BasicAuth_EncryptionType_Apr)
	if !ok {
		that2, ok := that.(BasicAuth_EncryptionType_Apr)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *UserSession_InternalSession) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*UserSession_InternalSession)
	if !ok {
		that2, ok := that.(UserSession_InternalSession)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetAllowRefreshing()).(equality.Equalizer); ok {
		if !h.Equal(target.GetAllowRefreshing()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetAllowRefreshing(), target.GetAllowRefreshing()) {
			return false
		}
	}

	if strings.Compare(m.GetKeyPrefix(), target.GetKeyPrefix()) != 0 {
		return false
	}

	if strings.Compare(m.GetTargetDomain(), target.GetTargetDomain()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *UserSession_RedisSession) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*UserSession_RedisSession)
	if !ok {
		that2, ok := that.(UserSession_RedisSession)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetOptions()).(equality.Equalizer); ok {
		if !h.Equal(target.GetOptions()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetOptions(), target.GetOptions()) {
			return false
		}
	}

	if strings.Compare(m.GetKeyPrefix(), target.GetKeyPrefix()) != 0 {
		return false
	}

	if strings.Compare(m.GetCookieName(), target.GetCookieName()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetAllowRefreshing()).(equality.Equalizer); ok {
		if !h.Equal(target.GetAllowRefreshing()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetAllowRefreshing(), target.GetAllowRefreshing()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetPreExpiryBuffer()).(equality.Equalizer); ok {
		if !h.Equal(target.GetPreExpiryBuffer()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetPreExpiryBuffer(), target.GetPreExpiryBuffer()) {
			return false
		}
	}

	if strings.Compare(m.GetTargetDomain(), target.GetTargetDomain()) != 0 {
		return false
	}

	if strings.Compare(m.GetHeaderName(), target.GetHeaderName()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *UserSession_CookieOptions) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*UserSession_CookieOptions)
	if !ok {
		that2, ok := that.(UserSession_CookieOptions)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetMaxAge()).(equality.Equalizer); ok {
		if !h.Equal(target.GetMaxAge()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetMaxAge(), target.GetMaxAge()) {
			return false
		}
	}

	if m.GetNotSecure() != target.GetNotSecure() {
		return false
	}

	if h, ok := interface{}(m.GetHttpOnly()).(equality.Equalizer); ok {
		if !h.Equal(target.GetHttpOnly()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetHttpOnly(), target.GetHttpOnly()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetPath()).(equality.Equalizer); ok {
		if !h.Equal(target.GetPath()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetPath(), target.GetPath()) {
			return false
		}
	}

	if m.GetSameSite() != target.GetSameSite() {
		return false
	}

	if strings.Compare(m.GetDomain(), target.GetDomain()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *UserSession_CipherConfig) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*UserSession_CipherConfig)
	if !ok {
		that2, ok := that.(UserSession_CipherConfig)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.Key.(type) {

	case *UserSession_CipherConfig_KeyRef:
		if _, ok := target.Key.(*UserSession_CipherConfig_KeyRef); !ok {
			return false
		}

		if h, ok := interface{}(m.GetKeyRef()).(equality.Equalizer); ok {
			if !h.Equal(target.GetKeyRef()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetKeyRef(), target.GetKeyRef()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.Key != target.Key {
			return false
		}
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_AccessToken) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_AccessToken)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_AccessToken)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetClaimsToHeaders()) != len(target.GetClaimsToHeaders()) {
		return false
	}
	for idx, v := range m.GetClaimsToHeaders() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetClaimsToHeaders()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetClaimsToHeaders()[idx]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_IdentityToken) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_IdentityToken)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_IdentityToken)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetClaimsToHeaders()) != len(target.GetClaimsToHeaders()) {
		return false
	}
	for idx, v := range m.GetClaimsToHeaders() {

		if h, ok := interface{}(v).(equality.Equalizer); ok {
			if !h.Equal(target.GetClaimsToHeaders()[idx]) {
				return false
			}
		} else {
			if !proto.Equal(v, target.GetClaimsToHeaders()[idx]) {
				return false
			}
		}

	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_ClientAuthentication) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_ClientAuthentication)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_ClientAuthentication)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.ClientAuthenticationConfig.(type) {

	case *OidcAuthorizationCode_ClientAuthentication_ClientSecret_:
		if _, ok := target.ClientAuthenticationConfig.(*OidcAuthorizationCode_ClientAuthentication_ClientSecret_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetClientSecret()).(equality.Equalizer); ok {
			if !h.Equal(target.GetClientSecret()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetClientSecret(), target.GetClientSecret()) {
				return false
			}
		}

	case *OidcAuthorizationCode_ClientAuthentication_PrivateKeyJwt_:
		if _, ok := target.ClientAuthenticationConfig.(*OidcAuthorizationCode_ClientAuthentication_PrivateKeyJwt_); !ok {
			return false
		}

		if h, ok := interface{}(m.GetPrivateKeyJwt()).(equality.Equalizer); ok {
			if !h.Equal(target.GetPrivateKeyJwt()) {
				return false
			}
		} else {
			if !proto.Equal(m.GetPrivateKeyJwt(), target.GetPrivateKeyJwt()) {
				return false
			}
		}

	default:
		// m is nil but target is not nil
		if m.ClientAuthenticationConfig != target.ClientAuthenticationConfig {
			return false
		}
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_Default) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_Default)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_Default)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_FrontChannelLogout) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_FrontChannelLogout)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_FrontChannelLogout)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetPath(), target.GetPath()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_ClientAuthentication_ClientSecret) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_ClientAuthentication_ClientSecret)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_ClientAuthentication_ClientSecret)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetClientSecretRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetClientSecretRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetClientSecretRef(), target.GetClientSecretRef()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetDisableClientSecret()).(equality.Equalizer); ok {
		if !h.Equal(target.GetDisableClientSecret()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetDisableClientSecret(), target.GetDisableClientSecret()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *OidcAuthorizationCode_ClientAuthentication_PrivateKeyJwt) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*OidcAuthorizationCode_ClientAuthentication_PrivateKeyJwt)
	if !ok {
		that2, ok := that.(OidcAuthorizationCode_ClientAuthentication_PrivateKeyJwt)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetSigningKeyRef()).(equality.Equalizer); ok {
		if !h.Equal(target.GetSigningKeyRef()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetSigningKeyRef(), target.GetSigningKeyRef()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetValidFor()).(equality.Equalizer); ok {
		if !h.Equal(target.GetValidFor()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetValidFor(), target.GetValidFor()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *JwtValidation_RemoteJwks) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*JwtValidation_RemoteJwks)
	if !ok {
		that2, ok := that.(JwtValidation_RemoteJwks)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetUrl(), target.GetUrl()) != 0 {
		return false
	}

	if h, ok := interface{}(m.GetRefreshInterval()).(equality.Equalizer); ok {
		if !h.Equal(target.GetRefreshInterval()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetRefreshInterval(), target.GetRefreshInterval()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *JwtValidation_LocalJwks) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*JwtValidation_LocalJwks)
	if !ok {
		that2, ok := that.(JwtValidation_LocalJwks)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetInlineString(), target.GetInlineString()) != 0 {
		return false
	}

	return true
}

// Equal function
func (m *AccessTokenValidation_Default) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AccessTokenValidation_Default)
	if !ok {
		that2, ok := that.(AccessTokenValidation_Default)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	return true
}

// Equal function
func (m *AccessTokenValidation_ScopeList) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AccessTokenValidation_ScopeList)
	if !ok {
		that2, ok := that.(AccessTokenValidation_ScopeList)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetScope()) != len(target.GetScope()) {
		return false
	}
	for idx, v := range m.GetScope() {

		if strings.Compare(v, target.GetScope()[idx]) != 0 {
			return false
		}

	}

	return true
}

// Equal function
func (m *ApiKeyAuth_SecretKey) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ApiKeyAuth_SecretKey)
	if !ok {
		that2, ok := that.(ApiKeyAuth_SecretKey)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetName(), target.GetName()) != 0 {
		return false
	}

	if m.GetRequired() != target.GetRequired() {
		return false
	}

	return true
}

// Equal function
func (m *ApiKeyAuth_MetadataEntry) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*ApiKeyAuth_MetadataEntry)
	if !ok {
		that2, ok := that.(ApiKeyAuth_MetadataEntry)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if strings.Compare(m.GetName(), target.GetName()) != 0 {
		return false
	}

	if m.GetRequired() != target.GetRequired() {
		return false
	}

	return true
}

// Equal function
func (m *AerospikeApiKeyStorageReadModeSc) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AerospikeApiKeyStorageReadModeSc)
	if !ok {
		that2, ok := that.(AerospikeApiKeyStorageReadModeSc)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.ReadModeSc.(type) {

	case *AerospikeApiKeyStorageReadModeSc_ReadModeScSession:
		if _, ok := target.ReadModeSc.(*AerospikeApiKeyStorageReadModeSc_ReadModeScSession); !ok {
			return false
		}

		if m.GetReadModeScSession() != target.GetReadModeScSession() {
			return false
		}

	case *AerospikeApiKeyStorageReadModeSc_ReadModeScLinearize:
		if _, ok := target.ReadModeSc.(*AerospikeApiKeyStorageReadModeSc_ReadModeScLinearize); !ok {
			return false
		}

		if m.GetReadModeScLinearize() != target.GetReadModeScLinearize() {
			return false
		}

	case *AerospikeApiKeyStorageReadModeSc_ReadModeScReplica:
		if _, ok := target.ReadModeSc.(*AerospikeApiKeyStorageReadModeSc_ReadModeScReplica); !ok {
			return false
		}

		if m.GetReadModeScReplica() != target.GetReadModeScReplica() {
			return false
		}

	case *AerospikeApiKeyStorageReadModeSc_ReadModeScAllowUnavailable:
		if _, ok := target.ReadModeSc.(*AerospikeApiKeyStorageReadModeSc_ReadModeScAllowUnavailable); !ok {
			return false
		}

		if m.GetReadModeScAllowUnavailable() != target.GetReadModeScAllowUnavailable() {
			return false
		}

	default:
		// m is nil but target is not nil
		if m.ReadModeSc != target.ReadModeSc {
			return false
		}
	}

	return true
}

// Equal function
func (m *AerospikeApiKeyStorageReadModeAp) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AerospikeApiKeyStorageReadModeAp)
	if !ok {
		that2, ok := that.(AerospikeApiKeyStorageReadModeAp)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.ReadModeAp.(type) {

	case *AerospikeApiKeyStorageReadModeAp_ReadModeApOne:
		if _, ok := target.ReadModeAp.(*AerospikeApiKeyStorageReadModeAp_ReadModeApOne); !ok {
			return false
		}

		if m.GetReadModeApOne() != target.GetReadModeApOne() {
			return false
		}

	case *AerospikeApiKeyStorageReadModeAp_ReadModeApAll:
		if _, ok := target.ReadModeAp.(*AerospikeApiKeyStorageReadModeAp_ReadModeApAll); !ok {
			return false
		}

		if m.GetReadModeApAll() != target.GetReadModeApAll() {
			return false
		}

	default:
		// m is nil but target is not nil
		if m.ReadModeAp != target.ReadModeAp {
			return false
		}
	}

	return true
}

// Equal function
func (m *AerospikeApiKeyStorageTlsCurveID) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*AerospikeApiKeyStorageTlsCurveID)
	if !ok {
		that2, ok := that.(AerospikeApiKeyStorageTlsCurveID)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	switch m.CurveId.(type) {

	case *AerospikeApiKeyStorageTlsCurveID_CurveP256:
		if _, ok := target.CurveId.(*AerospikeApiKeyStorageTlsCurveID_CurveP256); !ok {
			return false
		}

		if m.GetCurveP256() != target.GetCurveP256() {
			return false
		}

	case *AerospikeApiKeyStorageTlsCurveID_CurveP384:
		if _, ok := target.CurveId.(*AerospikeApiKeyStorageTlsCurveID_CurveP384); !ok {
			return false
		}

		if m.GetCurveP384() != target.GetCurveP384() {
			return false
		}

	case *AerospikeApiKeyStorageTlsCurveID_CurveP521:
		if _, ok := target.CurveId.(*AerospikeApiKeyStorageTlsCurveID_CurveP521); !ok {
			return false
		}

		if m.GetCurveP521() != target.GetCurveP521() {
			return false
		}

	case *AerospikeApiKeyStorageTlsCurveID_X_25519:
		if _, ok := target.CurveId.(*AerospikeApiKeyStorageTlsCurveID_X_25519); !ok {
			return false
		}

		if m.GetX_25519() != target.GetX_25519() {
			return false
		}

	default:
		// m is nil but target is not nil
		if m.CurveId != target.CurveId {
			return false
		}
	}

	return true
}

// Equal function
func (m *Ldap_ConnectionPool) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*Ldap_ConnectionPool)
	if !ok {
		that2, ok := that.(Ldap_ConnectionPool)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if h, ok := interface{}(m.GetMaxSize()).(equality.Equalizer); ok {
		if !h.Equal(target.GetMaxSize()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetMaxSize(), target.GetMaxSize()) {
			return false
		}
	}

	if h, ok := interface{}(m.GetInitialSize()).(equality.Equalizer); ok {
		if !h.Equal(target.GetInitialSize()) {
			return false
		}
	} else {
		if !proto.Equal(m.GetInitialSize(), target.GetInitialSize()) {
			return false
		}
	}

	return true
}

// Equal function
func (m *PassThroughHttp_Request) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughHttp_Request)
	if !ok {
		that2, ok := that.(PassThroughHttp_Request)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetAllowedHeaders()) != len(target.GetAllowedHeaders()) {
		return false
	}
	for idx, v := range m.GetAllowedHeaders() {

		if strings.Compare(v, target.GetAllowedHeaders()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetHeadersToAdd()) != len(target.GetHeadersToAdd()) {
		return false
	}
	for k, v := range m.GetHeadersToAdd() {

		if strings.Compare(v, target.GetHeadersToAdd()[k]) != 0 {
			return false
		}

	}

	if m.GetPassThroughState() != target.GetPassThroughState() {
		return false
	}

	if m.GetPassThroughFilterMetadata() != target.GetPassThroughFilterMetadata() {
		return false
	}

	if m.GetPassThroughBody() != target.GetPassThroughBody() {
		return false
	}

	return true
}

// Equal function
func (m *PassThroughHttp_Response) Equal(that interface{}) bool {
	if that == nil {
		return m == nil
	}

	target, ok := that.(*PassThroughHttp_Response)
	if !ok {
		that2, ok := that.(PassThroughHttp_Response)
		if ok {
			target = &that2
		} else {
			return false
		}
	}
	if target == nil {
		return m == nil
	} else if m == nil {
		return false
	}

	if len(m.GetAllowedUpstreamHeaders()) != len(target.GetAllowedUpstreamHeaders()) {
		return false
	}
	for idx, v := range m.GetAllowedUpstreamHeaders() {

		if strings.Compare(v, target.GetAllowedUpstreamHeaders()[idx]) != 0 {
			return false
		}

	}

	if len(m.GetAllowedClientHeadersOnDenied()) != len(target.GetAllowedClientHeadersOnDenied()) {
		return false
	}
	for idx, v := range m.GetAllowedClientHeadersOnDenied() {

		if strings.Compare(v, target.GetAllowedClientHeadersOnDenied()[idx]) != 0 {
			return false
		}

	}

	if m.GetReadStateFromResponse() != target.GetReadStateFromResponse() {
		return false
	}

	if len(m.GetAllowedUpstreamHeadersToOverwrite()) != len(target.GetAllowedUpstreamHeadersToOverwrite()) {
		return false
	}
	for idx, v := range m.GetAllowedUpstreamHeadersToOverwrite() {

		if strings.Compare(v, target.GetAllowedUpstreamHeadersToOverwrite()[idx]) != 0 {
			return false
		}

	}

	return true
}