edge-api/rest_management_api_server/operations/zt_edge_management_api.go

// Code generated by go-swagger; DO NOT EDIT.

//
// Copyright NetFoundry Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// __          __              _
// \ \        / /             (_)
//  \ \  /\  / /_ _ _ __ _ __  _ _ __   __ _
//   \ \/  \/ / _` | '__| '_ \| | '_ \ / _` |
//    \  /\  / (_| | |  | | | | | | | | (_| | : This file is generated, do not edit it.
//     \/  \/ \__,_|_|  |_| |_|_|_| |_|\__, |
//                                      __/ |
//                                     |___/

package operations

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"
	"io"
	"net/http"
	"strings"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/loads"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/runtime/middleware"
	"github.com/go-openapi/runtime/security"
	"github.com/go-openapi/spec"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"

	"github.com/hanzozt/edge-api/rest_management_api_server/operations/api_session"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/auth_policy"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/authentication"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/authenticator"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/certificate_authority"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/config"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/controllers"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/current_api_session"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/current_identity"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/database"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/edge_router"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/edge_router_policy"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/enrollment"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/external_jwt_signer"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/identity"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/informational"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/posture_checks"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/role_attributes"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/router"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/service"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/service_edge_router_policy"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/service_policy"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/session"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/settings"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/terminator"
	"github.com/hanzozt/edge-api/rest_management_api_server/operations/well_known"
)

// NewZitiEdgeManagementAPI creates a new ZitiEdgeManagement instance
func NewZitiEdgeManagementAPI(spec *loads.Document) *ZitiEdgeManagementAPI {
	return &ZitiEdgeManagementAPI{
		handlers:            make(map[string]map[string]http.Handler),
		formats:             strfmt.Default,
		defaultConsumes:     "application/json",
		defaultProduces:     "application/json",
		customConsumers:     make(map[string]runtime.Consumer),
		customProducers:     make(map[string]runtime.Producer),
		PreServerShutdown:   func() {},
		ServerShutdown:      func() {},
		spec:                spec,
		useSwaggerUI:        false,
		ServeError:          errors.ServeError,
		BasicAuthenticator:  security.BasicAuth,
		APIKeyAuthenticator: security.APIKeyAuth,
		BearerAuthenticator: security.BearerAuth,

		JSONConsumer: runtime.JSONConsumer(),
		TxtConsumer:  runtime.TextConsumer(),

		ApplicationJWTProducer: runtime.ProducerFunc(func(w io.Writer, data any) error {
			_ = w
			_ = data

			return errors.NotImplemented("applicationJwt producer has not yet been implemented")
		}),
		ApplicationPkcs7MimeProducer: runtime.ProducerFunc(func(w io.Writer, data any) error {
			_ = w
			_ = data

			return errors.NotImplemented("applicationPkcs7Mime producer has not yet been implemented")
		}),
		BinProducer:  runtime.ByteStreamProducer(),
		JSONProducer: runtime.JSONProducer(),
		TextYamlProducer: runtime.ProducerFunc(func(w io.Writer, data any) error {
			_ = w
			_ = data

			return errors.NotImplemented("textYaml producer has not yet been implemented")
		}),

		CurrentAPISessionDeleteCurrentAPISessionHandler: current_api_session.DeleteCurrentAPISessionHandlerFunc(func(params current_api_session.DeleteCurrentAPISessionParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.DeleteCurrentAPISession has not yet been implemented")
		}),

		IdentityAssociateIdentitysServiceConfigsHandler: identity.AssociateIdentitysServiceConfigsHandlerFunc(func(params identity.AssociateIdentitysServiceConfigsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.AssociateIdentitysServiceConfigs has not yet been implemented")
		}),

		AuthenticationAuthenticateHandler: authentication.AuthenticateHandlerFunc(func(params authentication.AuthenticateParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation authentication.Authenticate has not yet been implemented")
		}),

		AuthenticationAuthenticateMfaHandler: authentication.AuthenticateMfaHandlerFunc(func(params authentication.AuthenticateMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authentication.AuthenticateMfa has not yet been implemented")
		}),

		DatabaseCheckDataIntegrityHandler: database.CheckDataIntegrityHandlerFunc(func(params database.CheckDataIntegrityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation database.CheckDataIntegrity has not yet been implemented")
		}),

		AuthPolicyCreateAuthPolicyHandler: auth_policy.CreateAuthPolicyHandlerFunc(func(params auth_policy.CreateAuthPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.CreateAuthPolicy has not yet been implemented")
		}),

		AuthenticatorCreateAuthenticatorHandler: authenticator.CreateAuthenticatorHandlerFunc(func(params authenticator.CreateAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.CreateAuthenticator has not yet been implemented")
		}),

		CertificateAuthorityCreateCaHandler: certificate_authority.CreateCaHandlerFunc(func(params certificate_authority.CreateCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.CreateCa has not yet been implemented")
		}),

		ConfigCreateConfigHandler: config.CreateConfigHandlerFunc(func(params config.CreateConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.CreateConfig has not yet been implemented")
		}),

		ConfigCreateConfigTypeHandler: config.CreateConfigTypeHandlerFunc(func(params config.CreateConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.CreateConfigType has not yet been implemented")
		}),

		SettingsCreateControllerSettingHandler: settings.CreateControllerSettingHandlerFunc(func(params settings.CreateControllerSettingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.CreateControllerSetting has not yet been implemented")
		}),

		DatabaseCreateDatabaseSnapshotHandler: database.CreateDatabaseSnapshotHandlerFunc(func(params database.CreateDatabaseSnapshotParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation database.CreateDatabaseSnapshot has not yet been implemented")
		}),

		EdgeRouterCreateEdgeRouterHandler: edge_router.CreateEdgeRouterHandlerFunc(func(params edge_router.CreateEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.CreateEdgeRouter has not yet been implemented")
		}),

		EdgeRouterPolicyCreateEdgeRouterPolicyHandler: edge_router_policy.CreateEdgeRouterPolicyHandlerFunc(func(params edge_router_policy.CreateEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.CreateEdgeRouterPolicy has not yet been implemented")
		}),

		EnrollmentCreateEnrollmentHandler: enrollment.CreateEnrollmentHandlerFunc(func(params enrollment.CreateEnrollmentParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation enrollment.CreateEnrollment has not yet been implemented")
		}),

		ExternalJWTSignerCreateExternalJWTSignerHandler: external_jwt_signer.CreateExternalJWTSignerHandlerFunc(func(params external_jwt_signer.CreateExternalJWTSignerParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.CreateExternalJWTSigner has not yet been implemented")
		}),

		IdentityCreateIdentityHandler: identity.CreateIdentityHandlerFunc(func(params identity.CreateIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.CreateIdentity has not yet been implemented")
		}),

		CurrentIdentityCreateMfaRecoveryCodesHandler: current_identity.CreateMfaRecoveryCodesHandlerFunc(func(params current_identity.CreateMfaRecoveryCodesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.CreateMfaRecoveryCodes has not yet been implemented")
		}),

		PostureChecksCreatePostureCheckHandler: posture_checks.CreatePostureCheckHandlerFunc(func(params posture_checks.CreatePostureCheckParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.CreatePostureCheck has not yet been implemented")
		}),

		RouterCreateRouterHandler: router.CreateRouterHandlerFunc(func(params router.CreateRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.CreateRouter has not yet been implemented")
		}),

		ServiceCreateServiceHandler: service.CreateServiceHandlerFunc(func(params service.CreateServiceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.CreateService has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyCreateServiceEdgeRouterPolicyHandler: service_edge_router_policy.CreateServiceEdgeRouterPolicyHandlerFunc(func(params service_edge_router_policy.CreateServiceEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.CreateServiceEdgeRouterPolicy has not yet been implemented")
		}),

		ServicePolicyCreateServicePolicyHandler: service_policy.CreateServicePolicyHandlerFunc(func(params service_policy.CreateServicePolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.CreateServicePolicy has not yet been implemented")
		}),

		TerminatorCreateTerminatorHandler: terminator.CreateTerminatorHandlerFunc(func(params terminator.CreateTerminatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.CreateTerminator has not yet been implemented")
		}),

		CurrentAPISessionCreateTotpTokenHandler: current_api_session.CreateTotpTokenHandlerFunc(func(params current_api_session.CreateTotpTokenParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.CreateTotpToken has not yet been implemented")
		}),

		RouterCreateTransitRouterHandler: router.CreateTransitRouterHandlerFunc(func(params router.CreateTransitRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.CreateTransitRouter has not yet been implemented")
		}),

		DatabaseDataIntegrityResultsHandler: database.DataIntegrityResultsHandlerFunc(func(params database.DataIntegrityResultsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation database.DataIntegrityResults has not yet been implemented")
		}),

		APISessionDeleteAPISessionsHandler: api_session.DeleteAPISessionsHandlerFunc(func(params api_session.DeleteAPISessionsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation api_session.DeleteAPISessions has not yet been implemented")
		}),

		AuthPolicyDeleteAuthPolicyHandler: auth_policy.DeleteAuthPolicyHandlerFunc(func(params auth_policy.DeleteAuthPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.DeleteAuthPolicy has not yet been implemented")
		}),

		AuthenticatorDeleteAuthenticatorHandler: authenticator.DeleteAuthenticatorHandlerFunc(func(params authenticator.DeleteAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.DeleteAuthenticator has not yet been implemented")
		}),

		CertificateAuthorityDeleteCaHandler: certificate_authority.DeleteCaHandlerFunc(func(params certificate_authority.DeleteCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.DeleteCa has not yet been implemented")
		}),

		ConfigDeleteConfigHandler: config.DeleteConfigHandlerFunc(func(params config.DeleteConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.DeleteConfig has not yet been implemented")
		}),

		ConfigDeleteConfigTypeHandler: config.DeleteConfigTypeHandlerFunc(func(params config.DeleteConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.DeleteConfigType has not yet been implemented")
		}),

		SettingsDeleteControllerSettingHandler: settings.DeleteControllerSettingHandlerFunc(func(params settings.DeleteControllerSettingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.DeleteControllerSetting has not yet been implemented")
		}),

		EdgeRouterDeleteEdgeRouterHandler: edge_router.DeleteEdgeRouterHandlerFunc(func(params edge_router.DeleteEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.DeleteEdgeRouter has not yet been implemented")
		}),

		EdgeRouterPolicyDeleteEdgeRouterPolicyHandler: edge_router_policy.DeleteEdgeRouterPolicyHandlerFunc(func(params edge_router_policy.DeleteEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.DeleteEdgeRouterPolicy has not yet been implemented")
		}),

		EnrollmentDeleteEnrollmentHandler: enrollment.DeleteEnrollmentHandlerFunc(func(params enrollment.DeleteEnrollmentParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation enrollment.DeleteEnrollment has not yet been implemented")
		}),

		ExternalJWTSignerDeleteExternalJWTSignerHandler: external_jwt_signer.DeleteExternalJWTSignerHandlerFunc(func(params external_jwt_signer.DeleteExternalJWTSignerParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.DeleteExternalJWTSigner has not yet been implemented")
		}),

		IdentityDeleteIdentityHandler: identity.DeleteIdentityHandlerFunc(func(params identity.DeleteIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.DeleteIdentity has not yet been implemented")
		}),

		CurrentIdentityDeleteMfaHandler: current_identity.DeleteMfaHandlerFunc(func(params current_identity.DeleteMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.DeleteMfa has not yet been implemented")
		}),

		PostureChecksDeletePostureCheckHandler: posture_checks.DeletePostureCheckHandlerFunc(func(params posture_checks.DeletePostureCheckParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.DeletePostureCheck has not yet been implemented")
		}),

		RouterDeleteRouterHandler: router.DeleteRouterHandlerFunc(func(params router.DeleteRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.DeleteRouter has not yet been implemented")
		}),

		ServiceDeleteServiceHandler: service.DeleteServiceHandlerFunc(func(params service.DeleteServiceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.DeleteService has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyDeleteServiceEdgeRouterPolicyHandler: service_edge_router_policy.DeleteServiceEdgeRouterPolicyHandlerFunc(func(params service_edge_router_policy.DeleteServiceEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.DeleteServiceEdgeRouterPolicy has not yet been implemented")
		}),

		ServicePolicyDeleteServicePolicyHandler: service_policy.DeleteServicePolicyHandlerFunc(func(params service_policy.DeleteServicePolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.DeleteServicePolicy has not yet been implemented")
		}),

		SessionDeleteSessionHandler: session.DeleteSessionHandlerFunc(func(params session.DeleteSessionParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation session.DeleteSession has not yet been implemented")
		}),

		TerminatorDeleteTerminatorHandler: terminator.DeleteTerminatorHandlerFunc(func(params terminator.DeleteTerminatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.DeleteTerminator has not yet been implemented")
		}),

		RouterDeleteTransitRouterHandler: router.DeleteTransitRouterHandlerFunc(func(params router.DeleteTransitRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.DeleteTransitRouter has not yet been implemented")
		}),

		APISessionDetailAPISessionsHandler: api_session.DetailAPISessionsHandlerFunc(func(params api_session.DetailAPISessionsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation api_session.DetailAPISessions has not yet been implemented")
		}),

		AuthPolicyDetailAuthPolicyHandler: auth_policy.DetailAuthPolicyHandlerFunc(func(params auth_policy.DetailAuthPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.DetailAuthPolicy has not yet been implemented")
		}),

		AuthenticatorDetailAuthenticatorHandler: authenticator.DetailAuthenticatorHandlerFunc(func(params authenticator.DetailAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.DetailAuthenticator has not yet been implemented")
		}),

		CertificateAuthorityDetailCaHandler: certificate_authority.DetailCaHandlerFunc(func(params certificate_authority.DetailCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.DetailCa has not yet been implemented")
		}),

		ConfigDetailConfigHandler: config.DetailConfigHandlerFunc(func(params config.DetailConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.DetailConfig has not yet been implemented")
		}),

		ConfigDetailConfigTypeHandler: config.DetailConfigTypeHandlerFunc(func(params config.DetailConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.DetailConfigType has not yet been implemented")
		}),

		SettingsDetailControllerSettingHandler: settings.DetailControllerSettingHandlerFunc(func(params settings.DetailControllerSettingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.DetailControllerSetting has not yet been implemented")
		}),

		SettingsDetailControllerSettingEffectiveHandler: settings.DetailControllerSettingEffectiveHandlerFunc(func(params settings.DetailControllerSettingEffectiveParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.DetailControllerSettingEffective has not yet been implemented")
		}),

		CurrentAPISessionDetailCurrentIdentityAuthenticatorHandler: current_api_session.DetailCurrentIdentityAuthenticatorHandlerFunc(func(params current_api_session.DetailCurrentIdentityAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.DetailCurrentIdentityAuthenticator has not yet been implemented")
		}),

		EdgeRouterDetailEdgeRouterHandler: edge_router.DetailEdgeRouterHandlerFunc(func(params edge_router.DetailEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.DetailEdgeRouter has not yet been implemented")
		}),

		EdgeRouterPolicyDetailEdgeRouterPolicyHandler: edge_router_policy.DetailEdgeRouterPolicyHandlerFunc(func(params edge_router_policy.DetailEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.DetailEdgeRouterPolicy has not yet been implemented")
		}),

		EnrollmentDetailEnrollmentHandler: enrollment.DetailEnrollmentHandlerFunc(func(params enrollment.DetailEnrollmentParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation enrollment.DetailEnrollment has not yet been implemented")
		}),

		ExternalJWTSignerDetailExternalJWTSignerHandler: external_jwt_signer.DetailExternalJWTSignerHandlerFunc(func(params external_jwt_signer.DetailExternalJWTSignerParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.DetailExternalJWTSigner has not yet been implemented")
		}),

		IdentityDetailIdentityHandler: identity.DetailIdentityHandlerFunc(func(params identity.DetailIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.DetailIdentity has not yet been implemented")
		}),

		IdentityDetailIdentityTypeHandler: identity.DetailIdentityTypeHandlerFunc(func(params identity.DetailIdentityTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.DetailIdentityType has not yet been implemented")
		}),

		CurrentIdentityDetailMfaHandler: current_identity.DetailMfaHandlerFunc(func(params current_identity.DetailMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.DetailMfa has not yet been implemented")
		}),

		CurrentIdentityDetailMfaQrCodeHandler: current_identity.DetailMfaQrCodeHandlerFunc(func(params current_identity.DetailMfaQrCodeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.DetailMfaQrCode has not yet been implemented")
		}),

		CurrentIdentityDetailMfaRecoveryCodesHandler: current_identity.DetailMfaRecoveryCodesHandlerFunc(func(params current_identity.DetailMfaRecoveryCodesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.DetailMfaRecoveryCodes has not yet been implemented")
		}),

		PostureChecksDetailPostureCheckHandler: posture_checks.DetailPostureCheckHandlerFunc(func(params posture_checks.DetailPostureCheckParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.DetailPostureCheck has not yet been implemented")
		}),

		PostureChecksDetailPostureCheckTypeHandler: posture_checks.DetailPostureCheckTypeHandlerFunc(func(params posture_checks.DetailPostureCheckTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.DetailPostureCheckType has not yet been implemented")
		}),

		RouterDetailRouterHandler: router.DetailRouterHandlerFunc(func(params router.DetailRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.DetailRouter has not yet been implemented")
		}),

		ServiceDetailServiceHandler: service.DetailServiceHandlerFunc(func(params service.DetailServiceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.DetailService has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyDetailServiceEdgeRouterPolicyHandler: service_edge_router_policy.DetailServiceEdgeRouterPolicyHandlerFunc(func(params service_edge_router_policy.DetailServiceEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.DetailServiceEdgeRouterPolicy has not yet been implemented")
		}),

		ServicePolicyDetailServicePolicyHandler: service_policy.DetailServicePolicyHandlerFunc(func(params service_policy.DetailServicePolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.DetailServicePolicy has not yet been implemented")
		}),

		SessionDetailSessionHandler: session.DetailSessionHandlerFunc(func(params session.DetailSessionParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation session.DetailSession has not yet been implemented")
		}),

		SessionDetailSessionRoutePathHandler: session.DetailSessionRoutePathHandlerFunc(func(params session.DetailSessionRoutePathParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation session.DetailSessionRoutePath has not yet been implemented")
		}),

		InformationalDetailSpecHandler: informational.DetailSpecHandlerFunc(func(params informational.DetailSpecParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.DetailSpec has not yet been implemented")
		}),

		InformationalDetailSpecBodyHandler: informational.DetailSpecBodyHandlerFunc(func(params informational.DetailSpecBodyParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.DetailSpecBody has not yet been implemented")
		}),

		TerminatorDetailTerminatorHandler: terminator.DetailTerminatorHandlerFunc(func(params terminator.DetailTerminatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.DetailTerminator has not yet been implemented")
		}),

		RouterDetailTransitRouterHandler: router.DetailTransitRouterHandlerFunc(func(params router.DetailTransitRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.DetailTransitRouter has not yet been implemented")
		}),

		IdentityDisableIdentityHandler: identity.DisableIdentityHandlerFunc(func(params identity.DisableIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.DisableIdentity has not yet been implemented")
		}),

		IdentityDisassociateIdentitysServiceConfigsHandler: identity.DisassociateIdentitysServiceConfigsHandlerFunc(func(params identity.DisassociateIdentitysServiceConfigsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.DisassociateIdentitysServiceConfigs has not yet been implemented")
		}),

		IdentityEnableIdentityHandler: identity.EnableIdentityHandlerFunc(func(params identity.EnableIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.EnableIdentity has not yet been implemented")
		}),

		CurrentIdentityEnrollMfaHandler: current_identity.EnrollMfaHandlerFunc(func(params current_identity.EnrollMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.EnrollMfa has not yet been implemented")
		}),

		CurrentAPISessionExtendCurrentIdentityAuthenticatorHandler: current_api_session.ExtendCurrentIdentityAuthenticatorHandlerFunc(func(params current_api_session.ExtendCurrentIdentityAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.ExtendCurrentIdentityAuthenticator has not yet been implemented")
		}),

		CurrentAPISessionExtendVerifyCurrentIdentityAuthenticatorHandler: current_api_session.ExtendVerifyCurrentIdentityAuthenticatorHandlerFunc(func(params current_api_session.ExtendVerifyCurrentIdentityAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.ExtendVerifyCurrentIdentityAuthenticator has not yet been implemented")
		}),

		DatabaseFixDataIntegrityHandler: database.FixDataIntegrityHandlerFunc(func(params database.FixDataIntegrityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation database.FixDataIntegrity has not yet been implemented")
		}),

		CertificateAuthorityGetCaJWTHandler: certificate_authority.GetCaJWTHandlerFunc(func(params certificate_authority.GetCaJWTParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.GetCaJWT has not yet been implemented")
		}),

		CurrentAPISessionGetCurrentAPISessionHandler: current_api_session.GetCurrentAPISessionHandlerFunc(func(params current_api_session.GetCurrentAPISessionParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.GetCurrentAPISession has not yet been implemented")
		}),

		CurrentIdentityGetCurrentIdentityHandler: current_identity.GetCurrentIdentityHandlerFunc(func(params current_identity.GetCurrentIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.GetCurrentIdentity has not yet been implemented")
		}),

		IdentityGetIdentityAuthenticatorsHandler: identity.GetIdentityAuthenticatorsHandlerFunc(func(params identity.GetIdentityAuthenticatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.GetIdentityAuthenticators has not yet been implemented")
		}),

		IdentityGetIdentityEnrollmentsHandler: identity.GetIdentityEnrollmentsHandlerFunc(func(params identity.GetIdentityEnrollmentsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.GetIdentityEnrollments has not yet been implemented")
		}),

		IdentityGetIdentityFailedServiceRequestsHandler: identity.GetIdentityFailedServiceRequestsHandlerFunc(func(params identity.GetIdentityFailedServiceRequestsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.GetIdentityFailedServiceRequests has not yet been implemented")
		}),

		IdentityGetIdentityPolicyAdviceHandler: identity.GetIdentityPolicyAdviceHandlerFunc(func(params identity.GetIdentityPolicyAdviceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.GetIdentityPolicyAdvice has not yet been implemented")
		}),

		IdentityGetIdentityPostureDataHandler: identity.GetIdentityPostureDataHandlerFunc(func(params identity.GetIdentityPostureDataParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.GetIdentityPostureData has not yet been implemented")
		}),

		APISessionListAPISessionsHandler: api_session.ListAPISessionsHandlerFunc(func(params api_session.ListAPISessionsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation api_session.ListAPISessions has not yet been implemented")
		}),

		AuthPolicyListAuthPoliciesHandler: auth_policy.ListAuthPoliciesHandlerFunc(func(params auth_policy.ListAuthPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.ListAuthPolicies has not yet been implemented")
		}),

		AuthenticatorListAuthenticatorsHandler: authenticator.ListAuthenticatorsHandlerFunc(func(params authenticator.ListAuthenticatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.ListAuthenticators has not yet been implemented")
		}),

		CertificateAuthorityListCasHandler: certificate_authority.ListCasHandlerFunc(func(params certificate_authority.ListCasParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.ListCas has not yet been implemented")
		}),

		ConfigListConfigServicesHandler: config.ListConfigServicesHandlerFunc(func(params config.ListConfigServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.ListConfigServices has not yet been implemented")
		}),

		ConfigListConfigTypesHandler: config.ListConfigTypesHandlerFunc(func(params config.ListConfigTypesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.ListConfigTypes has not yet been implemented")
		}),

		ConfigListConfigsHandler: config.ListConfigsHandlerFunc(func(params config.ListConfigsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.ListConfigs has not yet been implemented")
		}),

		ConfigListConfigsForConfigTypeHandler: config.ListConfigsForConfigTypeHandlerFunc(func(params config.ListConfigsForConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.ListConfigsForConfigType has not yet been implemented")
		}),

		SettingsListControllerSettingsHandler: settings.ListControllerSettingsHandlerFunc(func(params settings.ListControllerSettingsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.ListControllerSettings has not yet been implemented")
		}),

		ControllersListControllersHandler: controllers.ListControllersHandlerFunc(func(params controllers.ListControllersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation controllers.ListControllers has not yet been implemented")
		}),

		CurrentAPISessionListCurrentIdentityAuthenticatorsHandler: current_api_session.ListCurrentIdentityAuthenticatorsHandlerFunc(func(params current_api_session.ListCurrentIdentityAuthenticatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.ListCurrentIdentityAuthenticators has not yet been implemented")
		}),

		EdgeRouterListEdgeRouterEdgeRouterPoliciesHandler: edge_router.ListEdgeRouterEdgeRouterPoliciesHandlerFunc(func(params edge_router.ListEdgeRouterEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ListEdgeRouterEdgeRouterPolicies has not yet been implemented")
		}),

		EdgeRouterListEdgeRouterIdentitiesHandler: edge_router.ListEdgeRouterIdentitiesHandlerFunc(func(params edge_router.ListEdgeRouterIdentitiesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ListEdgeRouterIdentities has not yet been implemented")
		}),

		EdgeRouterPolicyListEdgeRouterPoliciesHandler: edge_router_policy.ListEdgeRouterPoliciesHandlerFunc(func(params edge_router_policy.ListEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.ListEdgeRouterPolicies has not yet been implemented")
		}),

		EdgeRouterPolicyListEdgeRouterPolicyEdgeRoutersHandler: edge_router_policy.ListEdgeRouterPolicyEdgeRoutersHandlerFunc(func(params edge_router_policy.ListEdgeRouterPolicyEdgeRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.ListEdgeRouterPolicyEdgeRouters has not yet been implemented")
		}),

		EdgeRouterPolicyListEdgeRouterPolicyIdentitiesHandler: edge_router_policy.ListEdgeRouterPolicyIdentitiesHandlerFunc(func(params edge_router_policy.ListEdgeRouterPolicyIdentitiesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.ListEdgeRouterPolicyIdentities has not yet been implemented")
		}),

		RoleAttributesListEdgeRouterRoleAttributesHandler: role_attributes.ListEdgeRouterRoleAttributesHandlerFunc(func(params role_attributes.ListEdgeRouterRoleAttributesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation role_attributes.ListEdgeRouterRoleAttributes has not yet been implemented")
		}),

		EdgeRouterListEdgeRouterServiceEdgeRouterPoliciesHandler: edge_router.ListEdgeRouterServiceEdgeRouterPoliciesHandlerFunc(func(params edge_router.ListEdgeRouterServiceEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ListEdgeRouterServiceEdgeRouterPolicies has not yet been implemented")
		}),

		EdgeRouterListEdgeRouterServicesHandler: edge_router.ListEdgeRouterServicesHandlerFunc(func(params edge_router.ListEdgeRouterServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ListEdgeRouterServices has not yet been implemented")
		}),

		EdgeRouterListEdgeRoutersHandler: edge_router.ListEdgeRoutersHandlerFunc(func(params edge_router.ListEdgeRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ListEdgeRouters has not yet been implemented")
		}),

		EnrollmentListEnrollmentsHandler: enrollment.ListEnrollmentsHandlerFunc(func(params enrollment.ListEnrollmentsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation enrollment.ListEnrollments has not yet been implemented")
		}),

		InformationalListEnumeratedCapabilitiesHandler: informational.ListEnumeratedCapabilitiesHandlerFunc(func(params informational.ListEnumeratedCapabilitiesParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.ListEnumeratedCapabilities has not yet been implemented")
		}),

		ExternalJWTSignerListExternalJWTSignersHandler: external_jwt_signer.ListExternalJWTSignersHandlerFunc(func(params external_jwt_signer.ListExternalJWTSignersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.ListExternalJWTSigners has not yet been implemented")
		}),

		IdentityListIdentitiesHandler: identity.ListIdentitiesHandlerFunc(func(params identity.ListIdentitiesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentities has not yet been implemented")
		}),

		IdentityListIdentityEdgeRoutersHandler: identity.ListIdentityEdgeRoutersHandlerFunc(func(params identity.ListIdentityEdgeRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentityEdgeRouters has not yet been implemented")
		}),

		RoleAttributesListIdentityRoleAttributesHandler: role_attributes.ListIdentityRoleAttributesHandlerFunc(func(params role_attributes.ListIdentityRoleAttributesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation role_attributes.ListIdentityRoleAttributes has not yet been implemented")
		}),

		IdentityListIdentityServicePoliciesHandler: identity.ListIdentityServicePoliciesHandlerFunc(func(params identity.ListIdentityServicePoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentityServicePolicies has not yet been implemented")
		}),

		IdentityListIdentityServicesHandler: identity.ListIdentityServicesHandlerFunc(func(params identity.ListIdentityServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentityServices has not yet been implemented")
		}),

		IdentityListIdentityTypesHandler: identity.ListIdentityTypesHandlerFunc(func(params identity.ListIdentityTypesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentityTypes has not yet been implemented")
		}),

		IdentityListIdentitysEdgeRouterPoliciesHandler: identity.ListIdentitysEdgeRouterPoliciesHandlerFunc(func(params identity.ListIdentitysEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentitysEdgeRouterPolicies has not yet been implemented")
		}),

		IdentityListIdentitysServiceConfigsHandler: identity.ListIdentitysServiceConfigsHandlerFunc(func(params identity.ListIdentitysServiceConfigsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.ListIdentitysServiceConfigs has not yet been implemented")
		}),

		EnrollmentListNetworkJWTsHandler: enrollment.ListNetworkJWTsHandlerFunc(func(params enrollment.ListNetworkJWTsParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation enrollment.ListNetworkJWTs has not yet been implemented")
		}),

		RoleAttributesListPostureCheckRoleAttributesHandler: role_attributes.ListPostureCheckRoleAttributesHandlerFunc(func(params role_attributes.ListPostureCheckRoleAttributesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation role_attributes.ListPostureCheckRoleAttributes has not yet been implemented")
		}),

		PostureChecksListPostureCheckTypesHandler: posture_checks.ListPostureCheckTypesHandlerFunc(func(params posture_checks.ListPostureCheckTypesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.ListPostureCheckTypes has not yet been implemented")
		}),

		PostureChecksListPostureChecksHandler: posture_checks.ListPostureChecksHandlerFunc(func(params posture_checks.ListPostureChecksParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.ListPostureChecks has not yet been implemented")
		}),

		InformationalListRootHandler: informational.ListRootHandlerFunc(func(params informational.ListRootParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.ListRoot has not yet been implemented")
		}),

		RouterListRoutersHandler: router.ListRoutersHandlerFunc(func(params router.ListRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.ListRouters has not yet been implemented")
		}),

		ServiceListServiceConfigHandler: service.ListServiceConfigHandlerFunc(func(params service.ListServiceConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceConfig has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyListServiceEdgeRouterPoliciesHandler: service_edge_router_policy.ListServiceEdgeRouterPoliciesHandlerFunc(func(params service_edge_router_policy.ListServiceEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.ListServiceEdgeRouterPolicies has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyEdgeRoutersHandler: service_edge_router_policy.ListServiceEdgeRouterPolicyEdgeRoutersHandlerFunc(func(params service_edge_router_policy.ListServiceEdgeRouterPolicyEdgeRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.ListServiceEdgeRouterPolicyEdgeRouters has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyServicesHandler: service_edge_router_policy.ListServiceEdgeRouterPolicyServicesHandlerFunc(func(params service_edge_router_policy.ListServiceEdgeRouterPolicyServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.ListServiceEdgeRouterPolicyServices has not yet been implemented")
		}),

		ServiceListServiceEdgeRoutersHandler: service.ListServiceEdgeRoutersHandlerFunc(func(params service.ListServiceEdgeRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceEdgeRouters has not yet been implemented")
		}),

		ServiceListServiceIdentitiesHandler: service.ListServiceIdentitiesHandlerFunc(func(params service.ListServiceIdentitiesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceIdentities has not yet been implemented")
		}),

		ServicePolicyListServicePoliciesHandler: service_policy.ListServicePoliciesHandlerFunc(func(params service_policy.ListServicePoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.ListServicePolicies has not yet been implemented")
		}),

		ServicePolicyListServicePolicyIdentitiesHandler: service_policy.ListServicePolicyIdentitiesHandlerFunc(func(params service_policy.ListServicePolicyIdentitiesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.ListServicePolicyIdentities has not yet been implemented")
		}),

		ServicePolicyListServicePolicyPostureChecksHandler: service_policy.ListServicePolicyPostureChecksHandlerFunc(func(params service_policy.ListServicePolicyPostureChecksParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.ListServicePolicyPostureChecks has not yet been implemented")
		}),

		ServicePolicyListServicePolicyServicesHandler: service_policy.ListServicePolicyServicesHandlerFunc(func(params service_policy.ListServicePolicyServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.ListServicePolicyServices has not yet been implemented")
		}),

		RoleAttributesListServiceRoleAttributesHandler: role_attributes.ListServiceRoleAttributesHandlerFunc(func(params role_attributes.ListServiceRoleAttributesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation role_attributes.ListServiceRoleAttributes has not yet been implemented")
		}),

		ServiceListServiceServiceEdgeRouterPoliciesHandler: service.ListServiceServiceEdgeRouterPoliciesHandlerFunc(func(params service.ListServiceServiceEdgeRouterPoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceServiceEdgeRouterPolicies has not yet been implemented")
		}),

		ServiceListServiceServicePoliciesHandler: service.ListServiceServicePoliciesHandlerFunc(func(params service.ListServiceServicePoliciesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceServicePolicies has not yet been implemented")
		}),

		ServiceListServiceTerminatorsHandler: service.ListServiceTerminatorsHandlerFunc(func(params service.ListServiceTerminatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServiceTerminators has not yet been implemented")
		}),

		ServiceListServicesHandler: service.ListServicesHandlerFunc(func(params service.ListServicesParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.ListServices has not yet been implemented")
		}),

		SessionListSessionsHandler: session.ListSessionsHandlerFunc(func(params session.ListSessionsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation session.ListSessions has not yet been implemented")
		}),

		InformationalListSpecsHandler: informational.ListSpecsHandlerFunc(func(params informational.ListSpecsParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.ListSpecs has not yet been implemented")
		}),

		InformationalListSummaryHandler: informational.ListSummaryHandlerFunc(func(params informational.ListSummaryParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation informational.ListSummary has not yet been implemented")
		}),

		TerminatorListTerminatorsHandler: terminator.ListTerminatorsHandlerFunc(func(params terminator.ListTerminatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.ListTerminators has not yet been implemented")
		}),

		RouterListTransitRoutersHandler: router.ListTransitRoutersHandlerFunc(func(params router.ListTransitRoutersParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.ListTransitRouters has not yet been implemented")
		}),

		InformationalListVersionHandler: informational.ListVersionHandlerFunc(func(params informational.ListVersionParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation informational.ListVersion has not yet been implemented")
		}),

		WellKnownListWellKnownCasHandler: well_known.ListWellKnownCasHandlerFunc(func(params well_known.ListWellKnownCasParams) middleware.Responder {
			_ = params

			return middleware.NotImplemented("operation well_known.ListWellKnownCas has not yet been implemented")
		}),

		AuthPolicyPatchAuthPolicyHandler: auth_policy.PatchAuthPolicyHandlerFunc(func(params auth_policy.PatchAuthPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.PatchAuthPolicy has not yet been implemented")
		}),

		AuthenticatorPatchAuthenticatorHandler: authenticator.PatchAuthenticatorHandlerFunc(func(params authenticator.PatchAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.PatchAuthenticator has not yet been implemented")
		}),

		CertificateAuthorityPatchCaHandler: certificate_authority.PatchCaHandlerFunc(func(params certificate_authority.PatchCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.PatchCa has not yet been implemented")
		}),

		ConfigPatchConfigHandler: config.PatchConfigHandlerFunc(func(params config.PatchConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.PatchConfig has not yet been implemented")
		}),

		ConfigPatchConfigTypeHandler: config.PatchConfigTypeHandlerFunc(func(params config.PatchConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.PatchConfigType has not yet been implemented")
		}),

		SettingsPatchControllerSettingHandler: settings.PatchControllerSettingHandlerFunc(func(params settings.PatchControllerSettingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.PatchControllerSetting has not yet been implemented")
		}),

		CurrentAPISessionPatchCurrentIdentityAuthenticatorHandler: current_api_session.PatchCurrentIdentityAuthenticatorHandlerFunc(func(params current_api_session.PatchCurrentIdentityAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.PatchCurrentIdentityAuthenticator has not yet been implemented")
		}),

		EdgeRouterPatchEdgeRouterHandler: edge_router.PatchEdgeRouterHandlerFunc(func(params edge_router.PatchEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.PatchEdgeRouter has not yet been implemented")
		}),

		EdgeRouterPolicyPatchEdgeRouterPolicyHandler: edge_router_policy.PatchEdgeRouterPolicyHandlerFunc(func(params edge_router_policy.PatchEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.PatchEdgeRouterPolicy has not yet been implemented")
		}),

		ExternalJWTSignerPatchExternalJWTSignerHandler: external_jwt_signer.PatchExternalJWTSignerHandlerFunc(func(params external_jwt_signer.PatchExternalJWTSignerParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.PatchExternalJWTSigner has not yet been implemented")
		}),

		IdentityPatchIdentityHandler: identity.PatchIdentityHandlerFunc(func(params identity.PatchIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.PatchIdentity has not yet been implemented")
		}),

		PostureChecksPatchPostureCheckHandler: posture_checks.PatchPostureCheckHandlerFunc(func(params posture_checks.PatchPostureCheckParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.PatchPostureCheck has not yet been implemented")
		}),

		RouterPatchRouterHandler: router.PatchRouterHandlerFunc(func(params router.PatchRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.PatchRouter has not yet been implemented")
		}),

		ServicePatchServiceHandler: service.PatchServiceHandlerFunc(func(params service.PatchServiceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.PatchService has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyPatchServiceEdgeRouterPolicyHandler: service_edge_router_policy.PatchServiceEdgeRouterPolicyHandlerFunc(func(params service_edge_router_policy.PatchServiceEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.PatchServiceEdgeRouterPolicy has not yet been implemented")
		}),

		ServicePolicyPatchServicePolicyHandler: service_policy.PatchServicePolicyHandlerFunc(func(params service_policy.PatchServicePolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.PatchServicePolicy has not yet been implemented")
		}),

		TerminatorPatchTerminatorHandler: terminator.PatchTerminatorHandlerFunc(func(params terminator.PatchTerminatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.PatchTerminator has not yet been implemented")
		}),

		RouterPatchTransitRouterHandler: router.PatchTransitRouterHandlerFunc(func(params router.PatchTransitRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.PatchTransitRouter has not yet been implemented")
		}),

		AuthenticatorReEnrollAuthenticatorHandler: authenticator.ReEnrollAuthenticatorHandlerFunc(func(params authenticator.ReEnrollAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.ReEnrollAuthenticator has not yet been implemented")
		}),

		EdgeRouterReEnrollEdgeRouterHandler: edge_router.ReEnrollEdgeRouterHandlerFunc(func(params edge_router.ReEnrollEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.ReEnrollEdgeRouter has not yet been implemented")
		}),

		EnrollmentRefreshEnrollmentHandler: enrollment.RefreshEnrollmentHandlerFunc(func(params enrollment.RefreshEnrollmentParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation enrollment.RefreshEnrollment has not yet been implemented")
		}),

		IdentityRemoveIdentityMfaHandler: identity.RemoveIdentityMfaHandlerFunc(func(params identity.RemoveIdentityMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.RemoveIdentityMfa has not yet been implemented")
		}),

		AuthenticatorRequestExtendAllCertAuthenticatorsHandler: authenticator.RequestExtendAllCertAuthenticatorsHandlerFunc(func(params authenticator.RequestExtendAllCertAuthenticatorsParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.RequestExtendAllCertAuthenticators has not yet been implemented")
		}),

		AuthenticatorRequestExtendAuthenticatorHandler: authenticator.RequestExtendAuthenticatorHandlerFunc(func(params authenticator.RequestExtendAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.RequestExtendAuthenticator has not yet been implemented")
		}),

		AuthPolicyUpdateAuthPolicyHandler: auth_policy.UpdateAuthPolicyHandlerFunc(func(params auth_policy.UpdateAuthPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation auth_policy.UpdateAuthPolicy has not yet been implemented")
		}),

		AuthenticatorUpdateAuthenticatorHandler: authenticator.UpdateAuthenticatorHandlerFunc(func(params authenticator.UpdateAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation authenticator.UpdateAuthenticator has not yet been implemented")
		}),

		CertificateAuthorityUpdateCaHandler: certificate_authority.UpdateCaHandlerFunc(func(params certificate_authority.UpdateCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.UpdateCa has not yet been implemented")
		}),

		ConfigUpdateConfigHandler: config.UpdateConfigHandlerFunc(func(params config.UpdateConfigParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.UpdateConfig has not yet been implemented")
		}),

		ConfigUpdateConfigTypeHandler: config.UpdateConfigTypeHandlerFunc(func(params config.UpdateConfigTypeParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation config.UpdateConfigType has not yet been implemented")
		}),

		SettingsUpdateControllerSettingHandler: settings.UpdateControllerSettingHandlerFunc(func(params settings.UpdateControllerSettingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation settings.UpdateControllerSetting has not yet been implemented")
		}),

		CurrentAPISessionUpdateCurrentIdentityAuthenticatorHandler: current_api_session.UpdateCurrentIdentityAuthenticatorHandlerFunc(func(params current_api_session.UpdateCurrentIdentityAuthenticatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_api_session.UpdateCurrentIdentityAuthenticator has not yet been implemented")
		}),

		EdgeRouterUpdateEdgeRouterHandler: edge_router.UpdateEdgeRouterHandlerFunc(func(params edge_router.UpdateEdgeRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router.UpdateEdgeRouter has not yet been implemented")
		}),

		EdgeRouterPolicyUpdateEdgeRouterPolicyHandler: edge_router_policy.UpdateEdgeRouterPolicyHandlerFunc(func(params edge_router_policy.UpdateEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation edge_router_policy.UpdateEdgeRouterPolicy has not yet been implemented")
		}),

		ExternalJWTSignerUpdateExternalJWTSignerHandler: external_jwt_signer.UpdateExternalJWTSignerHandlerFunc(func(params external_jwt_signer.UpdateExternalJWTSignerParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation external_jwt_signer.UpdateExternalJWTSigner has not yet been implemented")
		}),

		IdentityUpdateIdentityHandler: identity.UpdateIdentityHandlerFunc(func(params identity.UpdateIdentityParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.UpdateIdentity has not yet been implemented")
		}),

		IdentityUpdateIdentityTracingHandler: identity.UpdateIdentityTracingHandlerFunc(func(params identity.UpdateIdentityTracingParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation identity.UpdateIdentityTracing has not yet been implemented")
		}),

		PostureChecksUpdatePostureCheckHandler: posture_checks.UpdatePostureCheckHandlerFunc(func(params posture_checks.UpdatePostureCheckParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation posture_checks.UpdatePostureCheck has not yet been implemented")
		}),

		RouterUpdateRouterHandler: router.UpdateRouterHandlerFunc(func(params router.UpdateRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.UpdateRouter has not yet been implemented")
		}),

		ServiceUpdateServiceHandler: service.UpdateServiceHandlerFunc(func(params service.UpdateServiceParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service.UpdateService has not yet been implemented")
		}),

		ServiceEdgeRouterPolicyUpdateServiceEdgeRouterPolicyHandler: service_edge_router_policy.UpdateServiceEdgeRouterPolicyHandlerFunc(func(params service_edge_router_policy.UpdateServiceEdgeRouterPolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_edge_router_policy.UpdateServiceEdgeRouterPolicy has not yet been implemented")
		}),

		ServicePolicyUpdateServicePolicyHandler: service_policy.UpdateServicePolicyHandlerFunc(func(params service_policy.UpdateServicePolicyParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation service_policy.UpdateServicePolicy has not yet been implemented")
		}),

		TerminatorUpdateTerminatorHandler: terminator.UpdateTerminatorHandlerFunc(func(params terminator.UpdateTerminatorParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation terminator.UpdateTerminator has not yet been implemented")
		}),

		RouterUpdateTransitRouterHandler: router.UpdateTransitRouterHandlerFunc(func(params router.UpdateTransitRouterParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation router.UpdateTransitRouter has not yet been implemented")
		}),

		CertificateAuthorityVerifyCaHandler: certificate_authority.VerifyCaHandlerFunc(func(params certificate_authority.VerifyCaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation certificate_authority.VerifyCa has not yet been implemented")
		}),

		CurrentIdentityVerifyMfaHandler: current_identity.VerifyMfaHandlerFunc(func(params current_identity.VerifyMfaParams, principal any) middleware.Responder {
			_ = params
			_ = principal

			return middleware.NotImplemented("operation current_identity.VerifyMfa has not yet been implemented")
		}),

		Oauth2Auth: func(token string, scopes []string) (any, error) {
			_ = token
			_ = scopes

			return nil, errors.NotImplemented("oauth2 bearer auth (oauth2) has not yet been implemented")
		},
		// Applies when the "zt-session" header is set
		ZtSessionAuth: func(token string) (any, error) {
			_ = token

			return nil, errors.NotImplemented("api key auth (ztSession) zt-session from header param [zt-session] has not yet been implemented")
		},
		// default authorizer is authorized meaning no requests are blocked
		APIAuthorizer: security.Authorized(),
	}
}

/*ZitiEdgeManagementAPI Hanzo ZT Edge Management API */
type ZitiEdgeManagementAPI struct {
	spec            *loads.Document
	context         *middleware.Context
	handlers        map[string]map[string]http.Handler
	formats         strfmt.Registry
	customConsumers map[string]runtime.Consumer
	customProducers map[string]runtime.Producer
	defaultConsumes string
	defaultProduces string
	Middleware      func(middleware.Builder) http.Handler
	useSwaggerUI    bool

	// BasicAuthenticator generates a runtime.Authenticator from the supplied basic auth function.
	// It has a default implementation in the security package, however you can replace it for your particular usage.
	BasicAuthenticator func(security.UserPassAuthentication) runtime.Authenticator

	// APIKeyAuthenticator generates a runtime.Authenticator from the supplied token auth function.
	// It has a default implementation in the security package, however you can replace it for your particular usage.
	APIKeyAuthenticator func(string, string, security.TokenAuthentication) runtime.Authenticator

	// BearerAuthenticator generates a runtime.Authenticator from the supplied bearer token auth function.
	// It has a default implementation in the security package, however you can replace it for your particular usage.
	BearerAuthenticator func(string, security.ScopedTokenAuthentication) runtime.Authenticator

	// JSONConsumer registers a consumer for the following mime types:
	//   - application/json
	JSONConsumer runtime.Consumer
	// TxtConsumer registers a consumer for the following mime types:
	//   - text/plain
	TxtConsumer runtime.Consumer

	// ApplicationJWTProducer registers a producer for the following mime types:
	//   - application/jwt
	ApplicationJWTProducer runtime.Producer
	// ApplicationPkcs7MimeProducer registers a producer for the following mime types:
	//   - application/pkcs7-mime
	ApplicationPkcs7MimeProducer runtime.Producer
	// BinProducer registers a producer for the following mime types:
	//   - image/png
	BinProducer runtime.Producer
	// JSONProducer registers a producer for the following mime types:
	//   - application/json
	JSONProducer runtime.Producer
	// TextYamlProducer registers a producer for the following mime types:
	//   - text/yaml
	TextYamlProducer runtime.Producer

	// Oauth2Auth registers a function that takes an access token and a collection of required scopes and returns a principal
	// it performs authentication based on an oauth2 bearer token provided in the request
	Oauth2Auth func(string, []string) (any, error)

	// ZtSessionAuth registers a function that takes a token and returns a principal
	// it performs authentication based on an api key zt-session provided in the header
	ZtSessionAuth func(string) (any, error)

	// APIAuthorizer provides access control (ACL/RBAC/ABAC) by providing access to the request and authenticated principal
	APIAuthorizer runtime.Authorizer

	// CurrentAPISessionDeleteCurrentAPISessionHandler sets the operation handler for the delete current API session operation
	CurrentAPISessionDeleteCurrentAPISessionHandler current_api_session.DeleteCurrentAPISessionHandler
	// IdentityAssociateIdentitysServiceConfigsHandler sets the operation handler for the associate identitys service configs operation
	IdentityAssociateIdentitysServiceConfigsHandler identity.AssociateIdentitysServiceConfigsHandler
	// AuthenticationAuthenticateHandler sets the operation handler for the authenticate operation
	AuthenticationAuthenticateHandler authentication.AuthenticateHandler
	// AuthenticationAuthenticateMfaHandler sets the operation handler for the authenticate mfa operation
	AuthenticationAuthenticateMfaHandler authentication.AuthenticateMfaHandler
	// DatabaseCheckDataIntegrityHandler sets the operation handler for the check data integrity operation
	DatabaseCheckDataIntegrityHandler database.CheckDataIntegrityHandler
	// AuthPolicyCreateAuthPolicyHandler sets the operation handler for the create auth policy operation
	AuthPolicyCreateAuthPolicyHandler auth_policy.CreateAuthPolicyHandler
	// AuthenticatorCreateAuthenticatorHandler sets the operation handler for the create authenticator operation
	AuthenticatorCreateAuthenticatorHandler authenticator.CreateAuthenticatorHandler
	// CertificateAuthorityCreateCaHandler sets the operation handler for the create ca operation
	CertificateAuthorityCreateCaHandler certificate_authority.CreateCaHandler
	// ConfigCreateConfigHandler sets the operation handler for the create config operation
	ConfigCreateConfigHandler config.CreateConfigHandler
	// ConfigCreateConfigTypeHandler sets the operation handler for the create config type operation
	ConfigCreateConfigTypeHandler config.CreateConfigTypeHandler
	// SettingsCreateControllerSettingHandler sets the operation handler for the create controller setting operation
	SettingsCreateControllerSettingHandler settings.CreateControllerSettingHandler
	// DatabaseCreateDatabaseSnapshotHandler sets the operation handler for the create database snapshot operation
	DatabaseCreateDatabaseSnapshotHandler database.CreateDatabaseSnapshotHandler
	// EdgeRouterCreateEdgeRouterHandler sets the operation handler for the create edge router operation
	EdgeRouterCreateEdgeRouterHandler edge_router.CreateEdgeRouterHandler
	// EdgeRouterPolicyCreateEdgeRouterPolicyHandler sets the operation handler for the create edge router policy operation
	EdgeRouterPolicyCreateEdgeRouterPolicyHandler edge_router_policy.CreateEdgeRouterPolicyHandler
	// EnrollmentCreateEnrollmentHandler sets the operation handler for the create enrollment operation
	EnrollmentCreateEnrollmentHandler enrollment.CreateEnrollmentHandler
	// ExternalJWTSignerCreateExternalJWTSignerHandler sets the operation handler for the create external Jwt signer operation
	ExternalJWTSignerCreateExternalJWTSignerHandler external_jwt_signer.CreateExternalJWTSignerHandler
	// IdentityCreateIdentityHandler sets the operation handler for the create identity operation
	IdentityCreateIdentityHandler identity.CreateIdentityHandler
	// CurrentIdentityCreateMfaRecoveryCodesHandler sets the operation handler for the create mfa recovery codes operation
	CurrentIdentityCreateMfaRecoveryCodesHandler current_identity.CreateMfaRecoveryCodesHandler
	// PostureChecksCreatePostureCheckHandler sets the operation handler for the create posture check operation
	PostureChecksCreatePostureCheckHandler posture_checks.CreatePostureCheckHandler
	// RouterCreateRouterHandler sets the operation handler for the create router operation
	RouterCreateRouterHandler router.CreateRouterHandler
	// ServiceCreateServiceHandler sets the operation handler for the create service operation
	ServiceCreateServiceHandler service.CreateServiceHandler
	// ServiceEdgeRouterPolicyCreateServiceEdgeRouterPolicyHandler sets the operation handler for the create service edge router policy operation
	ServiceEdgeRouterPolicyCreateServiceEdgeRouterPolicyHandler service_edge_router_policy.CreateServiceEdgeRouterPolicyHandler
	// ServicePolicyCreateServicePolicyHandler sets the operation handler for the create service policy operation
	ServicePolicyCreateServicePolicyHandler service_policy.CreateServicePolicyHandler
	// TerminatorCreateTerminatorHandler sets the operation handler for the create terminator operation
	TerminatorCreateTerminatorHandler terminator.CreateTerminatorHandler
	// CurrentAPISessionCreateTotpTokenHandler sets the operation handler for the create totp token operation
	CurrentAPISessionCreateTotpTokenHandler current_api_session.CreateTotpTokenHandler
	// RouterCreateTransitRouterHandler sets the operation handler for the create transit router operation
	RouterCreateTransitRouterHandler router.CreateTransitRouterHandler
	// DatabaseDataIntegrityResultsHandler sets the operation handler for the data integrity results operation
	DatabaseDataIntegrityResultsHandler database.DataIntegrityResultsHandler
	// APISessionDeleteAPISessionsHandler sets the operation handler for the delete API sessions operation
	APISessionDeleteAPISessionsHandler api_session.DeleteAPISessionsHandler
	// AuthPolicyDeleteAuthPolicyHandler sets the operation handler for the delete auth policy operation
	AuthPolicyDeleteAuthPolicyHandler auth_policy.DeleteAuthPolicyHandler
	// AuthenticatorDeleteAuthenticatorHandler sets the operation handler for the delete authenticator operation
	AuthenticatorDeleteAuthenticatorHandler authenticator.DeleteAuthenticatorHandler
	// CertificateAuthorityDeleteCaHandler sets the operation handler for the delete ca operation
	CertificateAuthorityDeleteCaHandler certificate_authority.DeleteCaHandler
	// ConfigDeleteConfigHandler sets the operation handler for the delete config operation
	ConfigDeleteConfigHandler config.DeleteConfigHandler
	// ConfigDeleteConfigTypeHandler sets the operation handler for the delete config type operation
	ConfigDeleteConfigTypeHandler config.DeleteConfigTypeHandler
	// SettingsDeleteControllerSettingHandler sets the operation handler for the delete controller setting operation
	SettingsDeleteControllerSettingHandler settings.DeleteControllerSettingHandler
	// EdgeRouterDeleteEdgeRouterHandler sets the operation handler for the delete edge router operation
	EdgeRouterDeleteEdgeRouterHandler edge_router.DeleteEdgeRouterHandler
	// EdgeRouterPolicyDeleteEdgeRouterPolicyHandler sets the operation handler for the delete edge router policy operation
	EdgeRouterPolicyDeleteEdgeRouterPolicyHandler edge_router_policy.DeleteEdgeRouterPolicyHandler
	// EnrollmentDeleteEnrollmentHandler sets the operation handler for the delete enrollment operation
	EnrollmentDeleteEnrollmentHandler enrollment.DeleteEnrollmentHandler
	// ExternalJWTSignerDeleteExternalJWTSignerHandler sets the operation handler for the delete external Jwt signer operation
	ExternalJWTSignerDeleteExternalJWTSignerHandler external_jwt_signer.DeleteExternalJWTSignerHandler
	// IdentityDeleteIdentityHandler sets the operation handler for the delete identity operation
	IdentityDeleteIdentityHandler identity.DeleteIdentityHandler
	// CurrentIdentityDeleteMfaHandler sets the operation handler for the delete mfa operation
	CurrentIdentityDeleteMfaHandler current_identity.DeleteMfaHandler
	// PostureChecksDeletePostureCheckHandler sets the operation handler for the delete posture check operation
	PostureChecksDeletePostureCheckHandler posture_checks.DeletePostureCheckHandler
	// RouterDeleteRouterHandler sets the operation handler for the delete router operation
	RouterDeleteRouterHandler router.DeleteRouterHandler
	// ServiceDeleteServiceHandler sets the operation handler for the delete service operation
	ServiceDeleteServiceHandler service.DeleteServiceHandler
	// ServiceEdgeRouterPolicyDeleteServiceEdgeRouterPolicyHandler sets the operation handler for the delete service edge router policy operation
	ServiceEdgeRouterPolicyDeleteServiceEdgeRouterPolicyHandler service_edge_router_policy.DeleteServiceEdgeRouterPolicyHandler
	// ServicePolicyDeleteServicePolicyHandler sets the operation handler for the delete service policy operation
	ServicePolicyDeleteServicePolicyHandler service_policy.DeleteServicePolicyHandler
	// SessionDeleteSessionHandler sets the operation handler for the delete session operation
	SessionDeleteSessionHandler session.DeleteSessionHandler
	// TerminatorDeleteTerminatorHandler sets the operation handler for the delete terminator operation
	TerminatorDeleteTerminatorHandler terminator.DeleteTerminatorHandler
	// RouterDeleteTransitRouterHandler sets the operation handler for the delete transit router operation
	RouterDeleteTransitRouterHandler router.DeleteTransitRouterHandler
	// APISessionDetailAPISessionsHandler sets the operation handler for the detail API sessions operation
	APISessionDetailAPISessionsHandler api_session.DetailAPISessionsHandler
	// AuthPolicyDetailAuthPolicyHandler sets the operation handler for the detail auth policy operation
	AuthPolicyDetailAuthPolicyHandler auth_policy.DetailAuthPolicyHandler
	// AuthenticatorDetailAuthenticatorHandler sets the operation handler for the detail authenticator operation
	AuthenticatorDetailAuthenticatorHandler authenticator.DetailAuthenticatorHandler
	// CertificateAuthorityDetailCaHandler sets the operation handler for the detail ca operation
	CertificateAuthorityDetailCaHandler certificate_authority.DetailCaHandler
	// ConfigDetailConfigHandler sets the operation handler for the detail config operation
	ConfigDetailConfigHandler config.DetailConfigHandler
	// ConfigDetailConfigTypeHandler sets the operation handler for the detail config type operation
	ConfigDetailConfigTypeHandler config.DetailConfigTypeHandler
	// SettingsDetailControllerSettingHandler sets the operation handler for the detail controller setting operation
	SettingsDetailControllerSettingHandler settings.DetailControllerSettingHandler
	// SettingsDetailControllerSettingEffectiveHandler sets the operation handler for the detail controller setting effective operation
	SettingsDetailControllerSettingEffectiveHandler settings.DetailControllerSettingEffectiveHandler
	// CurrentAPISessionDetailCurrentIdentityAuthenticatorHandler sets the operation handler for the detail current identity authenticator operation
	CurrentAPISessionDetailCurrentIdentityAuthenticatorHandler current_api_session.DetailCurrentIdentityAuthenticatorHandler
	// EdgeRouterDetailEdgeRouterHandler sets the operation handler for the detail edge router operation
	EdgeRouterDetailEdgeRouterHandler edge_router.DetailEdgeRouterHandler
	// EdgeRouterPolicyDetailEdgeRouterPolicyHandler sets the operation handler for the detail edge router policy operation
	EdgeRouterPolicyDetailEdgeRouterPolicyHandler edge_router_policy.DetailEdgeRouterPolicyHandler
	// EnrollmentDetailEnrollmentHandler sets the operation handler for the detail enrollment operation
	EnrollmentDetailEnrollmentHandler enrollment.DetailEnrollmentHandler
	// ExternalJWTSignerDetailExternalJWTSignerHandler sets the operation handler for the detail external Jwt signer operation
	ExternalJWTSignerDetailExternalJWTSignerHandler external_jwt_signer.DetailExternalJWTSignerHandler
	// IdentityDetailIdentityHandler sets the operation handler for the detail identity operation
	IdentityDetailIdentityHandler identity.DetailIdentityHandler
	// IdentityDetailIdentityTypeHandler sets the operation handler for the detail identity type operation
	IdentityDetailIdentityTypeHandler identity.DetailIdentityTypeHandler
	// CurrentIdentityDetailMfaHandler sets the operation handler for the detail mfa operation
	CurrentIdentityDetailMfaHandler current_identity.DetailMfaHandler
	// CurrentIdentityDetailMfaQrCodeHandler sets the operation handler for the detail mfa qr code operation
	CurrentIdentityDetailMfaQrCodeHandler current_identity.DetailMfaQrCodeHandler
	// CurrentIdentityDetailMfaRecoveryCodesHandler sets the operation handler for the detail mfa recovery codes operation
	CurrentIdentityDetailMfaRecoveryCodesHandler current_identity.DetailMfaRecoveryCodesHandler
	// PostureChecksDetailPostureCheckHandler sets the operation handler for the detail posture check operation
	PostureChecksDetailPostureCheckHandler posture_checks.DetailPostureCheckHandler
	// PostureChecksDetailPostureCheckTypeHandler sets the operation handler for the detail posture check type operation
	PostureChecksDetailPostureCheckTypeHandler posture_checks.DetailPostureCheckTypeHandler
	// RouterDetailRouterHandler sets the operation handler for the detail router operation
	RouterDetailRouterHandler router.DetailRouterHandler
	// ServiceDetailServiceHandler sets the operation handler for the detail service operation
	ServiceDetailServiceHandler service.DetailServiceHandler
	// ServiceEdgeRouterPolicyDetailServiceEdgeRouterPolicyHandler sets the operation handler for the detail service edge router policy operation
	ServiceEdgeRouterPolicyDetailServiceEdgeRouterPolicyHandler service_edge_router_policy.DetailServiceEdgeRouterPolicyHandler
	// ServicePolicyDetailServicePolicyHandler sets the operation handler for the detail service policy operation
	ServicePolicyDetailServicePolicyHandler service_policy.DetailServicePolicyHandler
	// SessionDetailSessionHandler sets the operation handler for the detail session operation
	SessionDetailSessionHandler session.DetailSessionHandler
	// SessionDetailSessionRoutePathHandler sets the operation handler for the detail session route path operation
	SessionDetailSessionRoutePathHandler session.DetailSessionRoutePathHandler
	// InformationalDetailSpecHandler sets the operation handler for the detail spec operation
	InformationalDetailSpecHandler informational.DetailSpecHandler
	// InformationalDetailSpecBodyHandler sets the operation handler for the detail spec body operation
	InformationalDetailSpecBodyHandler informational.DetailSpecBodyHandler
	// TerminatorDetailTerminatorHandler sets the operation handler for the detail terminator operation
	TerminatorDetailTerminatorHandler terminator.DetailTerminatorHandler
	// RouterDetailTransitRouterHandler sets the operation handler for the detail transit router operation
	RouterDetailTransitRouterHandler router.DetailTransitRouterHandler
	// IdentityDisableIdentityHandler sets the operation handler for the disable identity operation
	IdentityDisableIdentityHandler identity.DisableIdentityHandler
	// IdentityDisassociateIdentitysServiceConfigsHandler sets the operation handler for the disassociate identitys service configs operation
	IdentityDisassociateIdentitysServiceConfigsHandler identity.DisassociateIdentitysServiceConfigsHandler
	// IdentityEnableIdentityHandler sets the operation handler for the enable identity operation
	IdentityEnableIdentityHandler identity.EnableIdentityHandler
	// CurrentIdentityEnrollMfaHandler sets the operation handler for the enroll mfa operation
	CurrentIdentityEnrollMfaHandler current_identity.EnrollMfaHandler
	// CurrentAPISessionExtendCurrentIdentityAuthenticatorHandler sets the operation handler for the extend current identity authenticator operation
	CurrentAPISessionExtendCurrentIdentityAuthenticatorHandler current_api_session.ExtendCurrentIdentityAuthenticatorHandler
	// CurrentAPISessionExtendVerifyCurrentIdentityAuthenticatorHandler sets the operation handler for the extend verify current identity authenticator operation
	CurrentAPISessionExtendVerifyCurrentIdentityAuthenticatorHandler current_api_session.ExtendVerifyCurrentIdentityAuthenticatorHandler
	// DatabaseFixDataIntegrityHandler sets the operation handler for the fix data integrity operation
	DatabaseFixDataIntegrityHandler database.FixDataIntegrityHandler
	// CertificateAuthorityGetCaJWTHandler sets the operation handler for the get ca Jwt operation
	CertificateAuthorityGetCaJWTHandler certificate_authority.GetCaJWTHandler
	// CurrentAPISessionGetCurrentAPISessionHandler sets the operation handler for the get current API session operation
	CurrentAPISessionGetCurrentAPISessionHandler current_api_session.GetCurrentAPISessionHandler
	// CurrentIdentityGetCurrentIdentityHandler sets the operation handler for the get current identity operation
	CurrentIdentityGetCurrentIdentityHandler current_identity.GetCurrentIdentityHandler
	// IdentityGetIdentityAuthenticatorsHandler sets the operation handler for the get identity authenticators operation
	IdentityGetIdentityAuthenticatorsHandler identity.GetIdentityAuthenticatorsHandler
	// IdentityGetIdentityEnrollmentsHandler sets the operation handler for the get identity enrollments operation
	IdentityGetIdentityEnrollmentsHandler identity.GetIdentityEnrollmentsHandler
	// IdentityGetIdentityFailedServiceRequestsHandler sets the operation handler for the get identity failed service requests operation
	IdentityGetIdentityFailedServiceRequestsHandler identity.GetIdentityFailedServiceRequestsHandler
	// IdentityGetIdentityPolicyAdviceHandler sets the operation handler for the get identity policy advice operation
	IdentityGetIdentityPolicyAdviceHandler identity.GetIdentityPolicyAdviceHandler
	// IdentityGetIdentityPostureDataHandler sets the operation handler for the get identity posture data operation
	IdentityGetIdentityPostureDataHandler identity.GetIdentityPostureDataHandler
	// APISessionListAPISessionsHandler sets the operation handler for the list API sessions operation
	APISessionListAPISessionsHandler api_session.ListAPISessionsHandler
	// AuthPolicyListAuthPoliciesHandler sets the operation handler for the list auth policies operation
	AuthPolicyListAuthPoliciesHandler auth_policy.ListAuthPoliciesHandler
	// AuthenticatorListAuthenticatorsHandler sets the operation handler for the list authenticators operation
	AuthenticatorListAuthenticatorsHandler authenticator.ListAuthenticatorsHandler
	// CertificateAuthorityListCasHandler sets the operation handler for the list cas operation
	CertificateAuthorityListCasHandler certificate_authority.ListCasHandler
	// ConfigListConfigServicesHandler sets the operation handler for the list config services operation
	ConfigListConfigServicesHandler config.ListConfigServicesHandler
	// ConfigListConfigTypesHandler sets the operation handler for the list config types operation
	ConfigListConfigTypesHandler config.ListConfigTypesHandler
	// ConfigListConfigsHandler sets the operation handler for the list configs operation
	ConfigListConfigsHandler config.ListConfigsHandler
	// ConfigListConfigsForConfigTypeHandler sets the operation handler for the list configs for config type operation
	ConfigListConfigsForConfigTypeHandler config.ListConfigsForConfigTypeHandler
	// SettingsListControllerSettingsHandler sets the operation handler for the list controller settings operation
	SettingsListControllerSettingsHandler settings.ListControllerSettingsHandler
	// ControllersListControllersHandler sets the operation handler for the list controllers operation
	ControllersListControllersHandler controllers.ListControllersHandler
	// CurrentAPISessionListCurrentIdentityAuthenticatorsHandler sets the operation handler for the list current identity authenticators operation
	CurrentAPISessionListCurrentIdentityAuthenticatorsHandler current_api_session.ListCurrentIdentityAuthenticatorsHandler
	// EdgeRouterListEdgeRouterEdgeRouterPoliciesHandler sets the operation handler for the list edge router edge router policies operation
	EdgeRouterListEdgeRouterEdgeRouterPoliciesHandler edge_router.ListEdgeRouterEdgeRouterPoliciesHandler
	// EdgeRouterListEdgeRouterIdentitiesHandler sets the operation handler for the list edge router identities operation
	EdgeRouterListEdgeRouterIdentitiesHandler edge_router.ListEdgeRouterIdentitiesHandler
	// EdgeRouterPolicyListEdgeRouterPoliciesHandler sets the operation handler for the list edge router policies operation
	EdgeRouterPolicyListEdgeRouterPoliciesHandler edge_router_policy.ListEdgeRouterPoliciesHandler
	// EdgeRouterPolicyListEdgeRouterPolicyEdgeRoutersHandler sets the operation handler for the list edge router policy edge routers operation
	EdgeRouterPolicyListEdgeRouterPolicyEdgeRoutersHandler edge_router_policy.ListEdgeRouterPolicyEdgeRoutersHandler
	// EdgeRouterPolicyListEdgeRouterPolicyIdentitiesHandler sets the operation handler for the list edge router policy identities operation
	EdgeRouterPolicyListEdgeRouterPolicyIdentitiesHandler edge_router_policy.ListEdgeRouterPolicyIdentitiesHandler
	// RoleAttributesListEdgeRouterRoleAttributesHandler sets the operation handler for the list edge router role attributes operation
	RoleAttributesListEdgeRouterRoleAttributesHandler role_attributes.ListEdgeRouterRoleAttributesHandler
	// EdgeRouterListEdgeRouterServiceEdgeRouterPoliciesHandler sets the operation handler for the list edge router service edge router policies operation
	EdgeRouterListEdgeRouterServiceEdgeRouterPoliciesHandler edge_router.ListEdgeRouterServiceEdgeRouterPoliciesHandler
	// EdgeRouterListEdgeRouterServicesHandler sets the operation handler for the list edge router services operation
	EdgeRouterListEdgeRouterServicesHandler edge_router.ListEdgeRouterServicesHandler
	// EdgeRouterListEdgeRoutersHandler sets the operation handler for the list edge routers operation
	EdgeRouterListEdgeRoutersHandler edge_router.ListEdgeRoutersHandler
	// EnrollmentListEnrollmentsHandler sets the operation handler for the list enrollments operation
	EnrollmentListEnrollmentsHandler enrollment.ListEnrollmentsHandler
	// InformationalListEnumeratedCapabilitiesHandler sets the operation handler for the list enumerated capabilities operation
	InformationalListEnumeratedCapabilitiesHandler informational.ListEnumeratedCapabilitiesHandler
	// ExternalJWTSignerListExternalJWTSignersHandler sets the operation handler for the list external Jwt signers operation
	ExternalJWTSignerListExternalJWTSignersHandler external_jwt_signer.ListExternalJWTSignersHandler
	// IdentityListIdentitiesHandler sets the operation handler for the list identities operation
	IdentityListIdentitiesHandler identity.ListIdentitiesHandler
	// IdentityListIdentityEdgeRoutersHandler sets the operation handler for the list identity edge routers operation
	IdentityListIdentityEdgeRoutersHandler identity.ListIdentityEdgeRoutersHandler
	// RoleAttributesListIdentityRoleAttributesHandler sets the operation handler for the list identity role attributes operation
	RoleAttributesListIdentityRoleAttributesHandler role_attributes.ListIdentityRoleAttributesHandler
	// IdentityListIdentityServicePoliciesHandler sets the operation handler for the list identity service policies operation
	IdentityListIdentityServicePoliciesHandler identity.ListIdentityServicePoliciesHandler
	// IdentityListIdentityServicesHandler sets the operation handler for the list identity services operation
	IdentityListIdentityServicesHandler identity.ListIdentityServicesHandler
	// IdentityListIdentityTypesHandler sets the operation handler for the list identity types operation
	IdentityListIdentityTypesHandler identity.ListIdentityTypesHandler
	// IdentityListIdentitysEdgeRouterPoliciesHandler sets the operation handler for the list identitys edge router policies operation
	IdentityListIdentitysEdgeRouterPoliciesHandler identity.ListIdentitysEdgeRouterPoliciesHandler
	// IdentityListIdentitysServiceConfigsHandler sets the operation handler for the list identitys service configs operation
	IdentityListIdentitysServiceConfigsHandler identity.ListIdentitysServiceConfigsHandler
	// EnrollmentListNetworkJWTsHandler sets the operation handler for the list network j w ts operation
	EnrollmentListNetworkJWTsHandler enrollment.ListNetworkJWTsHandler
	// RoleAttributesListPostureCheckRoleAttributesHandler sets the operation handler for the list posture check role attributes operation
	RoleAttributesListPostureCheckRoleAttributesHandler role_attributes.ListPostureCheckRoleAttributesHandler
	// PostureChecksListPostureCheckTypesHandler sets the operation handler for the list posture check types operation
	PostureChecksListPostureCheckTypesHandler posture_checks.ListPostureCheckTypesHandler
	// PostureChecksListPostureChecksHandler sets the operation handler for the list posture checks operation
	PostureChecksListPostureChecksHandler posture_checks.ListPostureChecksHandler
	// InformationalListRootHandler sets the operation handler for the list root operation
	InformationalListRootHandler informational.ListRootHandler
	// RouterListRoutersHandler sets the operation handler for the list routers operation
	RouterListRoutersHandler router.ListRoutersHandler
	// ServiceListServiceConfigHandler sets the operation handler for the list service config operation
	ServiceListServiceConfigHandler service.ListServiceConfigHandler
	// ServiceEdgeRouterPolicyListServiceEdgeRouterPoliciesHandler sets the operation handler for the list service edge router policies operation
	ServiceEdgeRouterPolicyListServiceEdgeRouterPoliciesHandler service_edge_router_policy.ListServiceEdgeRouterPoliciesHandler
	// ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyEdgeRoutersHandler sets the operation handler for the list service edge router policy edge routers operation
	ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyEdgeRoutersHandler service_edge_router_policy.ListServiceEdgeRouterPolicyEdgeRoutersHandler
	// ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyServicesHandler sets the operation handler for the list service edge router policy services operation
	ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyServicesHandler service_edge_router_policy.ListServiceEdgeRouterPolicyServicesHandler
	// ServiceListServiceEdgeRoutersHandler sets the operation handler for the list service edge routers operation
	ServiceListServiceEdgeRoutersHandler service.ListServiceEdgeRoutersHandler
	// ServiceListServiceIdentitiesHandler sets the operation handler for the list service identities operation
	ServiceListServiceIdentitiesHandler service.ListServiceIdentitiesHandler
	// ServicePolicyListServicePoliciesHandler sets the operation handler for the list service policies operation
	ServicePolicyListServicePoliciesHandler service_policy.ListServicePoliciesHandler
	// ServicePolicyListServicePolicyIdentitiesHandler sets the operation handler for the list service policy identities operation
	ServicePolicyListServicePolicyIdentitiesHandler service_policy.ListServicePolicyIdentitiesHandler
	// ServicePolicyListServicePolicyPostureChecksHandler sets the operation handler for the list service policy posture checks operation
	ServicePolicyListServicePolicyPostureChecksHandler service_policy.ListServicePolicyPostureChecksHandler
	// ServicePolicyListServicePolicyServicesHandler sets the operation handler for the list service policy services operation
	ServicePolicyListServicePolicyServicesHandler service_policy.ListServicePolicyServicesHandler
	// RoleAttributesListServiceRoleAttributesHandler sets the operation handler for the list service role attributes operation
	RoleAttributesListServiceRoleAttributesHandler role_attributes.ListServiceRoleAttributesHandler
	// ServiceListServiceServiceEdgeRouterPoliciesHandler sets the operation handler for the list service service edge router policies operation
	ServiceListServiceServiceEdgeRouterPoliciesHandler service.ListServiceServiceEdgeRouterPoliciesHandler
	// ServiceListServiceServicePoliciesHandler sets the operation handler for the list service service policies operation
	ServiceListServiceServicePoliciesHandler service.ListServiceServicePoliciesHandler
	// ServiceListServiceTerminatorsHandler sets the operation handler for the list service terminators operation
	ServiceListServiceTerminatorsHandler service.ListServiceTerminatorsHandler
	// ServiceListServicesHandler sets the operation handler for the list services operation
	ServiceListServicesHandler service.ListServicesHandler
	// SessionListSessionsHandler sets the operation handler for the list sessions operation
	SessionListSessionsHandler session.ListSessionsHandler
	// InformationalListSpecsHandler sets the operation handler for the list specs operation
	InformationalListSpecsHandler informational.ListSpecsHandler
	// InformationalListSummaryHandler sets the operation handler for the list summary operation
	InformationalListSummaryHandler informational.ListSummaryHandler
	// TerminatorListTerminatorsHandler sets the operation handler for the list terminators operation
	TerminatorListTerminatorsHandler terminator.ListTerminatorsHandler
	// RouterListTransitRoutersHandler sets the operation handler for the list transit routers operation
	RouterListTransitRoutersHandler router.ListTransitRoutersHandler
	// InformationalListVersionHandler sets the operation handler for the list version operation
	InformationalListVersionHandler informational.ListVersionHandler
	// WellKnownListWellKnownCasHandler sets the operation handler for the list well known cas operation
	WellKnownListWellKnownCasHandler well_known.ListWellKnownCasHandler
	// AuthPolicyPatchAuthPolicyHandler sets the operation handler for the patch auth policy operation
	AuthPolicyPatchAuthPolicyHandler auth_policy.PatchAuthPolicyHandler
	// AuthenticatorPatchAuthenticatorHandler sets the operation handler for the patch authenticator operation
	AuthenticatorPatchAuthenticatorHandler authenticator.PatchAuthenticatorHandler
	// CertificateAuthorityPatchCaHandler sets the operation handler for the patch ca operation
	CertificateAuthorityPatchCaHandler certificate_authority.PatchCaHandler
	// ConfigPatchConfigHandler sets the operation handler for the patch config operation
	ConfigPatchConfigHandler config.PatchConfigHandler
	// ConfigPatchConfigTypeHandler sets the operation handler for the patch config type operation
	ConfigPatchConfigTypeHandler config.PatchConfigTypeHandler
	// SettingsPatchControllerSettingHandler sets the operation handler for the patch controller setting operation
	SettingsPatchControllerSettingHandler settings.PatchControllerSettingHandler
	// CurrentAPISessionPatchCurrentIdentityAuthenticatorHandler sets the operation handler for the patch current identity authenticator operation
	CurrentAPISessionPatchCurrentIdentityAuthenticatorHandler current_api_session.PatchCurrentIdentityAuthenticatorHandler
	// EdgeRouterPatchEdgeRouterHandler sets the operation handler for the patch edge router operation
	EdgeRouterPatchEdgeRouterHandler edge_router.PatchEdgeRouterHandler
	// EdgeRouterPolicyPatchEdgeRouterPolicyHandler sets the operation handler for the patch edge router policy operation
	EdgeRouterPolicyPatchEdgeRouterPolicyHandler edge_router_policy.PatchEdgeRouterPolicyHandler
	// ExternalJWTSignerPatchExternalJWTSignerHandler sets the operation handler for the patch external Jwt signer operation
	ExternalJWTSignerPatchExternalJWTSignerHandler external_jwt_signer.PatchExternalJWTSignerHandler
	// IdentityPatchIdentityHandler sets the operation handler for the patch identity operation
	IdentityPatchIdentityHandler identity.PatchIdentityHandler
	// PostureChecksPatchPostureCheckHandler sets the operation handler for the patch posture check operation
	PostureChecksPatchPostureCheckHandler posture_checks.PatchPostureCheckHandler
	// RouterPatchRouterHandler sets the operation handler for the patch router operation
	RouterPatchRouterHandler router.PatchRouterHandler
	// ServicePatchServiceHandler sets the operation handler for the patch service operation
	ServicePatchServiceHandler service.PatchServiceHandler
	// ServiceEdgeRouterPolicyPatchServiceEdgeRouterPolicyHandler sets the operation handler for the patch service edge router policy operation
	ServiceEdgeRouterPolicyPatchServiceEdgeRouterPolicyHandler service_edge_router_policy.PatchServiceEdgeRouterPolicyHandler
	// ServicePolicyPatchServicePolicyHandler sets the operation handler for the patch service policy operation
	ServicePolicyPatchServicePolicyHandler service_policy.PatchServicePolicyHandler
	// TerminatorPatchTerminatorHandler sets the operation handler for the patch terminator operation
	TerminatorPatchTerminatorHandler terminator.PatchTerminatorHandler
	// RouterPatchTransitRouterHandler sets the operation handler for the patch transit router operation
	RouterPatchTransitRouterHandler router.PatchTransitRouterHandler
	// AuthenticatorReEnrollAuthenticatorHandler sets the operation handler for the re enroll authenticator operation
	AuthenticatorReEnrollAuthenticatorHandler authenticator.ReEnrollAuthenticatorHandler
	// EdgeRouterReEnrollEdgeRouterHandler sets the operation handler for the re enroll edge router operation
	EdgeRouterReEnrollEdgeRouterHandler edge_router.ReEnrollEdgeRouterHandler
	// EnrollmentRefreshEnrollmentHandler sets the operation handler for the refresh enrollment operation
	EnrollmentRefreshEnrollmentHandler enrollment.RefreshEnrollmentHandler
	// IdentityRemoveIdentityMfaHandler sets the operation handler for the remove identity mfa operation
	IdentityRemoveIdentityMfaHandler identity.RemoveIdentityMfaHandler
	// AuthenticatorRequestExtendAllCertAuthenticatorsHandler sets the operation handler for the request extend all cert authenticators operation
	AuthenticatorRequestExtendAllCertAuthenticatorsHandler authenticator.RequestExtendAllCertAuthenticatorsHandler
	// AuthenticatorRequestExtendAuthenticatorHandler sets the operation handler for the request extend authenticator operation
	AuthenticatorRequestExtendAuthenticatorHandler authenticator.RequestExtendAuthenticatorHandler
	// AuthPolicyUpdateAuthPolicyHandler sets the operation handler for the update auth policy operation
	AuthPolicyUpdateAuthPolicyHandler auth_policy.UpdateAuthPolicyHandler
	// AuthenticatorUpdateAuthenticatorHandler sets the operation handler for the update authenticator operation
	AuthenticatorUpdateAuthenticatorHandler authenticator.UpdateAuthenticatorHandler
	// CertificateAuthorityUpdateCaHandler sets the operation handler for the update ca operation
	CertificateAuthorityUpdateCaHandler certificate_authority.UpdateCaHandler
	// ConfigUpdateConfigHandler sets the operation handler for the update config operation
	ConfigUpdateConfigHandler config.UpdateConfigHandler
	// ConfigUpdateConfigTypeHandler sets the operation handler for the update config type operation
	ConfigUpdateConfigTypeHandler config.UpdateConfigTypeHandler
	// SettingsUpdateControllerSettingHandler sets the operation handler for the update controller setting operation
	SettingsUpdateControllerSettingHandler settings.UpdateControllerSettingHandler
	// CurrentAPISessionUpdateCurrentIdentityAuthenticatorHandler sets the operation handler for the update current identity authenticator operation
	CurrentAPISessionUpdateCurrentIdentityAuthenticatorHandler current_api_session.UpdateCurrentIdentityAuthenticatorHandler
	// EdgeRouterUpdateEdgeRouterHandler sets the operation handler for the update edge router operation
	EdgeRouterUpdateEdgeRouterHandler edge_router.UpdateEdgeRouterHandler
	// EdgeRouterPolicyUpdateEdgeRouterPolicyHandler sets the operation handler for the update edge router policy operation
	EdgeRouterPolicyUpdateEdgeRouterPolicyHandler edge_router_policy.UpdateEdgeRouterPolicyHandler
	// ExternalJWTSignerUpdateExternalJWTSignerHandler sets the operation handler for the update external Jwt signer operation
	ExternalJWTSignerUpdateExternalJWTSignerHandler external_jwt_signer.UpdateExternalJWTSignerHandler
	// IdentityUpdateIdentityHandler sets the operation handler for the update identity operation
	IdentityUpdateIdentityHandler identity.UpdateIdentityHandler
	// IdentityUpdateIdentityTracingHandler sets the operation handler for the update identity tracing operation
	IdentityUpdateIdentityTracingHandler identity.UpdateIdentityTracingHandler
	// PostureChecksUpdatePostureCheckHandler sets the operation handler for the update posture check operation
	PostureChecksUpdatePostureCheckHandler posture_checks.UpdatePostureCheckHandler
	// RouterUpdateRouterHandler sets the operation handler for the update router operation
	RouterUpdateRouterHandler router.UpdateRouterHandler
	// ServiceUpdateServiceHandler sets the operation handler for the update service operation
	ServiceUpdateServiceHandler service.UpdateServiceHandler
	// ServiceEdgeRouterPolicyUpdateServiceEdgeRouterPolicyHandler sets the operation handler for the update service edge router policy operation
	ServiceEdgeRouterPolicyUpdateServiceEdgeRouterPolicyHandler service_edge_router_policy.UpdateServiceEdgeRouterPolicyHandler
	// ServicePolicyUpdateServicePolicyHandler sets the operation handler for the update service policy operation
	ServicePolicyUpdateServicePolicyHandler service_policy.UpdateServicePolicyHandler
	// TerminatorUpdateTerminatorHandler sets the operation handler for the update terminator operation
	TerminatorUpdateTerminatorHandler terminator.UpdateTerminatorHandler
	// RouterUpdateTransitRouterHandler sets the operation handler for the update transit router operation
	RouterUpdateTransitRouterHandler router.UpdateTransitRouterHandler
	// CertificateAuthorityVerifyCaHandler sets the operation handler for the verify ca operation
	CertificateAuthorityVerifyCaHandler certificate_authority.VerifyCaHandler
	// CurrentIdentityVerifyMfaHandler sets the operation handler for the verify mfa operation
	CurrentIdentityVerifyMfaHandler current_identity.VerifyMfaHandler

	// ServeError is called when an error is received, there is a default handler
	// but you can set your own with this
	ServeError func(http.ResponseWriter, *http.Request, error)

	// PreServerShutdown is called before the HTTP(S) server is shutdown
	// This allows for custom functions to get executed before the HTTP(S) server stops accepting traffic
	PreServerShutdown func()

	// ServerShutdown is called when the HTTP(S) server is shut down and done
	// handling all active connections and does not accept connections any more
	ServerShutdown func()

	// Custom command line argument groups with their descriptions
	CommandLineOptionsGroups []swag.CommandLineOptionsGroup

	// User defined logger function.
	Logger func(string, ...any)
}

// UseRedoc for documentation at /docs
func (o *ZitiEdgeManagementAPI) UseRedoc() {
	o.useSwaggerUI = false
}

// UseSwaggerUI for documentation at /docs
func (o *ZitiEdgeManagementAPI) UseSwaggerUI() {
	o.useSwaggerUI = true
}

// SetDefaultProduces sets the default produces media type
func (o *ZitiEdgeManagementAPI) SetDefaultProduces(mediaType string) {
	o.defaultProduces = mediaType
}

// SetDefaultConsumes returns the default consumes media type
func (o *ZitiEdgeManagementAPI) SetDefaultConsumes(mediaType string) {
	o.defaultConsumes = mediaType
}

// SetSpec sets a spec that will be served for the clients.
func (o *ZitiEdgeManagementAPI) SetSpec(spec *loads.Document) {
	o.spec = spec
}

// DefaultProduces returns the default produces media type
func (o *ZitiEdgeManagementAPI) DefaultProduces() string {
	return o.defaultProduces
}

// DefaultConsumes returns the default consumes media type
func (o *ZitiEdgeManagementAPI) DefaultConsumes() string {
	return o.defaultConsumes
}

// Formats returns the registered string formats
func (o *ZitiEdgeManagementAPI) Formats() strfmt.Registry {
	return o.formats
}

// RegisterFormat registers a custom format validator
func (o *ZitiEdgeManagementAPI) RegisterFormat(name string, format strfmt.Format, validator strfmt.Validator) {
	o.formats.Add(name, format, validator)
}

// Validate validates the registrations in the ZitiEdgeManagementAPI
func (o *ZitiEdgeManagementAPI) Validate() error {
	var unregistered []string

	if o.JSONConsumer == nil {
		unregistered = append(unregistered, "JSONConsumer")
	}
	if o.TxtConsumer == nil {
		unregistered = append(unregistered, "TxtConsumer")
	}

	if o.ApplicationJWTProducer == nil {
		unregistered = append(unregistered, "ApplicationJWTProducer")
	}
	if o.ApplicationPkcs7MimeProducer == nil {
		unregistered = append(unregistered, "ApplicationPkcs7MimeProducer")
	}
	if o.BinProducer == nil {
		unregistered = append(unregistered, "BinProducer")
	}
	if o.JSONProducer == nil {
		unregistered = append(unregistered, "JSONProducer")
	}
	if o.TextYamlProducer == nil {
		unregistered = append(unregistered, "TextYamlProducer")
	}

	if o.Oauth2Auth == nil {
		unregistered = append(unregistered, "Oauth2Auth")
	}
	if o.ZtSessionAuth == nil {
		unregistered = append(unregistered, "ZtSessionAuth")
	}

	if o.CurrentAPISessionDeleteCurrentAPISessionHandler == nil {
		unregistered = append(unregistered, "current_api_session.DeleteCurrentAPISessionHandler")
	}
	if o.IdentityAssociateIdentitysServiceConfigsHandler == nil {
		unregistered = append(unregistered, "identity.AssociateIdentitysServiceConfigsHandler")
	}
	if o.AuthenticationAuthenticateHandler == nil {
		unregistered = append(unregistered, "authentication.AuthenticateHandler")
	}
	if o.AuthenticationAuthenticateMfaHandler == nil {
		unregistered = append(unregistered, "authentication.AuthenticateMfaHandler")
	}
	if o.DatabaseCheckDataIntegrityHandler == nil {
		unregistered = append(unregistered, "database.CheckDataIntegrityHandler")
	}
	if o.AuthPolicyCreateAuthPolicyHandler == nil {
		unregistered = append(unregistered, "auth_policy.CreateAuthPolicyHandler")
	}
	if o.AuthenticatorCreateAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.CreateAuthenticatorHandler")
	}
	if o.CertificateAuthorityCreateCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.CreateCaHandler")
	}
	if o.ConfigCreateConfigHandler == nil {
		unregistered = append(unregistered, "config.CreateConfigHandler")
	}
	if o.ConfigCreateConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.CreateConfigTypeHandler")
	}
	if o.SettingsCreateControllerSettingHandler == nil {
		unregistered = append(unregistered, "settings.CreateControllerSettingHandler")
	}
	if o.DatabaseCreateDatabaseSnapshotHandler == nil {
		unregistered = append(unregistered, "database.CreateDatabaseSnapshotHandler")
	}
	if o.EdgeRouterCreateEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.CreateEdgeRouterHandler")
	}
	if o.EdgeRouterPolicyCreateEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.CreateEdgeRouterPolicyHandler")
	}
	if o.EnrollmentCreateEnrollmentHandler == nil {
		unregistered = append(unregistered, "enrollment.CreateEnrollmentHandler")
	}
	if o.ExternalJWTSignerCreateExternalJWTSignerHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.CreateExternalJWTSignerHandler")
	}
	if o.IdentityCreateIdentityHandler == nil {
		unregistered = append(unregistered, "identity.CreateIdentityHandler")
	}
	if o.CurrentIdentityCreateMfaRecoveryCodesHandler == nil {
		unregistered = append(unregistered, "current_identity.CreateMfaRecoveryCodesHandler")
	}
	if o.PostureChecksCreatePostureCheckHandler == nil {
		unregistered = append(unregistered, "posture_checks.CreatePostureCheckHandler")
	}
	if o.RouterCreateRouterHandler == nil {
		unregistered = append(unregistered, "router.CreateRouterHandler")
	}
	if o.ServiceCreateServiceHandler == nil {
		unregistered = append(unregistered, "service.CreateServiceHandler")
	}
	if o.ServiceEdgeRouterPolicyCreateServiceEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.CreateServiceEdgeRouterPolicyHandler")
	}
	if o.ServicePolicyCreateServicePolicyHandler == nil {
		unregistered = append(unregistered, "service_policy.CreateServicePolicyHandler")
	}
	if o.TerminatorCreateTerminatorHandler == nil {
		unregistered = append(unregistered, "terminator.CreateTerminatorHandler")
	}
	if o.CurrentAPISessionCreateTotpTokenHandler == nil {
		unregistered = append(unregistered, "current_api_session.CreateTotpTokenHandler")
	}
	if o.RouterCreateTransitRouterHandler == nil {
		unregistered = append(unregistered, "router.CreateTransitRouterHandler")
	}
	if o.DatabaseDataIntegrityResultsHandler == nil {
		unregistered = append(unregistered, "database.DataIntegrityResultsHandler")
	}
	if o.APISessionDeleteAPISessionsHandler == nil {
		unregistered = append(unregistered, "api_session.DeleteAPISessionsHandler")
	}
	if o.AuthPolicyDeleteAuthPolicyHandler == nil {
		unregistered = append(unregistered, "auth_policy.DeleteAuthPolicyHandler")
	}
	if o.AuthenticatorDeleteAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.DeleteAuthenticatorHandler")
	}
	if o.CertificateAuthorityDeleteCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.DeleteCaHandler")
	}
	if o.ConfigDeleteConfigHandler == nil {
		unregistered = append(unregistered, "config.DeleteConfigHandler")
	}
	if o.ConfigDeleteConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.DeleteConfigTypeHandler")
	}
	if o.SettingsDeleteControllerSettingHandler == nil {
		unregistered = append(unregistered, "settings.DeleteControllerSettingHandler")
	}
	if o.EdgeRouterDeleteEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.DeleteEdgeRouterHandler")
	}
	if o.EdgeRouterPolicyDeleteEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.DeleteEdgeRouterPolicyHandler")
	}
	if o.EnrollmentDeleteEnrollmentHandler == nil {
		unregistered = append(unregistered, "enrollment.DeleteEnrollmentHandler")
	}
	if o.ExternalJWTSignerDeleteExternalJWTSignerHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.DeleteExternalJWTSignerHandler")
	}
	if o.IdentityDeleteIdentityHandler == nil {
		unregistered = append(unregistered, "identity.DeleteIdentityHandler")
	}
	if o.CurrentIdentityDeleteMfaHandler == nil {
		unregistered = append(unregistered, "current_identity.DeleteMfaHandler")
	}
	if o.PostureChecksDeletePostureCheckHandler == nil {
		unregistered = append(unregistered, "posture_checks.DeletePostureCheckHandler")
	}
	if o.RouterDeleteRouterHandler == nil {
		unregistered = append(unregistered, "router.DeleteRouterHandler")
	}
	if o.ServiceDeleteServiceHandler == nil {
		unregistered = append(unregistered, "service.DeleteServiceHandler")
	}
	if o.ServiceEdgeRouterPolicyDeleteServiceEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.DeleteServiceEdgeRouterPolicyHandler")
	}
	if o.ServicePolicyDeleteServicePolicyHandler == nil {
		unregistered = append(unregistered, "service_policy.DeleteServicePolicyHandler")
	}
	if o.SessionDeleteSessionHandler == nil {
		unregistered = append(unregistered, "session.DeleteSessionHandler")
	}
	if o.TerminatorDeleteTerminatorHandler == nil {
		unregistered = append(unregistered, "terminator.DeleteTerminatorHandler")
	}
	if o.RouterDeleteTransitRouterHandler == nil {
		unregistered = append(unregistered, "router.DeleteTransitRouterHandler")
	}
	if o.APISessionDetailAPISessionsHandler == nil {
		unregistered = append(unregistered, "api_session.DetailAPISessionsHandler")
	}
	if o.AuthPolicyDetailAuthPolicyHandler == nil {
		unregistered = append(unregistered, "auth_policy.DetailAuthPolicyHandler")
	}
	if o.AuthenticatorDetailAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.DetailAuthenticatorHandler")
	}
	if o.CertificateAuthorityDetailCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.DetailCaHandler")
	}
	if o.ConfigDetailConfigHandler == nil {
		unregistered = append(unregistered, "config.DetailConfigHandler")
	}
	if o.ConfigDetailConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.DetailConfigTypeHandler")
	}
	if o.SettingsDetailControllerSettingHandler == nil {
		unregistered = append(unregistered, "settings.DetailControllerSettingHandler")
	}
	if o.SettingsDetailControllerSettingEffectiveHandler == nil {
		unregistered = append(unregistered, "settings.DetailControllerSettingEffectiveHandler")
	}
	if o.CurrentAPISessionDetailCurrentIdentityAuthenticatorHandler == nil {
		unregistered = append(unregistered, "current_api_session.DetailCurrentIdentityAuthenticatorHandler")
	}
	if o.EdgeRouterDetailEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.DetailEdgeRouterHandler")
	}
	if o.EdgeRouterPolicyDetailEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.DetailEdgeRouterPolicyHandler")
	}
	if o.EnrollmentDetailEnrollmentHandler == nil {
		unregistered = append(unregistered, "enrollment.DetailEnrollmentHandler")
	}
	if o.ExternalJWTSignerDetailExternalJWTSignerHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.DetailExternalJWTSignerHandler")
	}
	if o.IdentityDetailIdentityHandler == nil {
		unregistered = append(unregistered, "identity.DetailIdentityHandler")
	}
	if o.IdentityDetailIdentityTypeHandler == nil {
		unregistered = append(unregistered, "identity.DetailIdentityTypeHandler")
	}
	if o.CurrentIdentityDetailMfaHandler == nil {
		unregistered = append(unregistered, "current_identity.DetailMfaHandler")
	}
	if o.CurrentIdentityDetailMfaQrCodeHandler == nil {
		unregistered = append(unregistered, "current_identity.DetailMfaQrCodeHandler")
	}
	if o.CurrentIdentityDetailMfaRecoveryCodesHandler == nil {
		unregistered = append(unregistered, "current_identity.DetailMfaRecoveryCodesHandler")
	}
	if o.PostureChecksDetailPostureCheckHandler == nil {
		unregistered = append(unregistered, "posture_checks.DetailPostureCheckHandler")
	}
	if o.PostureChecksDetailPostureCheckTypeHandler == nil {
		unregistered = append(unregistered, "posture_checks.DetailPostureCheckTypeHandler")
	}
	if o.RouterDetailRouterHandler == nil {
		unregistered = append(unregistered, "router.DetailRouterHandler")
	}
	if o.ServiceDetailServiceHandler == nil {
		unregistered = append(unregistered, "service.DetailServiceHandler")
	}
	if o.ServiceEdgeRouterPolicyDetailServiceEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.DetailServiceEdgeRouterPolicyHandler")
	}
	if o.ServicePolicyDetailServicePolicyHandler == nil {
		unregistered = append(unregistered, "service_policy.DetailServicePolicyHandler")
	}
	if o.SessionDetailSessionHandler == nil {
		unregistered = append(unregistered, "session.DetailSessionHandler")
	}
	if o.SessionDetailSessionRoutePathHandler == nil {
		unregistered = append(unregistered, "session.DetailSessionRoutePathHandler")
	}
	if o.InformationalDetailSpecHandler == nil {
		unregistered = append(unregistered, "informational.DetailSpecHandler")
	}
	if o.InformationalDetailSpecBodyHandler == nil {
		unregistered = append(unregistered, "informational.DetailSpecBodyHandler")
	}
	if o.TerminatorDetailTerminatorHandler == nil {
		unregistered = append(unregistered, "terminator.DetailTerminatorHandler")
	}
	if o.RouterDetailTransitRouterHandler == nil {
		unregistered = append(unregistered, "router.DetailTransitRouterHandler")
	}
	if o.IdentityDisableIdentityHandler == nil {
		unregistered = append(unregistered, "identity.DisableIdentityHandler")
	}
	if o.IdentityDisassociateIdentitysServiceConfigsHandler == nil {
		unregistered = append(unregistered, "identity.DisassociateIdentitysServiceConfigsHandler")
	}
	if o.IdentityEnableIdentityHandler == nil {
		unregistered = append(unregistered, "identity.EnableIdentityHandler")
	}
	if o.CurrentIdentityEnrollMfaHandler == nil {
		unregistered = append(unregistered, "current_identity.EnrollMfaHandler")
	}
	if o.CurrentAPISessionExtendCurrentIdentityAuthenticatorHandler == nil {
		unregistered = append(unregistered, "current_api_session.ExtendCurrentIdentityAuthenticatorHandler")
	}
	if o.CurrentAPISessionExtendVerifyCurrentIdentityAuthenticatorHandler == nil {
		unregistered = append(unregistered, "current_api_session.ExtendVerifyCurrentIdentityAuthenticatorHandler")
	}
	if o.DatabaseFixDataIntegrityHandler == nil {
		unregistered = append(unregistered, "database.FixDataIntegrityHandler")
	}
	if o.CertificateAuthorityGetCaJWTHandler == nil {
		unregistered = append(unregistered, "certificate_authority.GetCaJWTHandler")
	}
	if o.CurrentAPISessionGetCurrentAPISessionHandler == nil {
		unregistered = append(unregistered, "current_api_session.GetCurrentAPISessionHandler")
	}
	if o.CurrentIdentityGetCurrentIdentityHandler == nil {
		unregistered = append(unregistered, "current_identity.GetCurrentIdentityHandler")
	}
	if o.IdentityGetIdentityAuthenticatorsHandler == nil {
		unregistered = append(unregistered, "identity.GetIdentityAuthenticatorsHandler")
	}
	if o.IdentityGetIdentityEnrollmentsHandler == nil {
		unregistered = append(unregistered, "identity.GetIdentityEnrollmentsHandler")
	}
	if o.IdentityGetIdentityFailedServiceRequestsHandler == nil {
		unregistered = append(unregistered, "identity.GetIdentityFailedServiceRequestsHandler")
	}
	if o.IdentityGetIdentityPolicyAdviceHandler == nil {
		unregistered = append(unregistered, "identity.GetIdentityPolicyAdviceHandler")
	}
	if o.IdentityGetIdentityPostureDataHandler == nil {
		unregistered = append(unregistered, "identity.GetIdentityPostureDataHandler")
	}
	if o.APISessionListAPISessionsHandler == nil {
		unregistered = append(unregistered, "api_session.ListAPISessionsHandler")
	}
	if o.AuthPolicyListAuthPoliciesHandler == nil {
		unregistered = append(unregistered, "auth_policy.ListAuthPoliciesHandler")
	}
	if o.AuthenticatorListAuthenticatorsHandler == nil {
		unregistered = append(unregistered, "authenticator.ListAuthenticatorsHandler")
	}
	if o.CertificateAuthorityListCasHandler == nil {
		unregistered = append(unregistered, "certificate_authority.ListCasHandler")
	}
	if o.ConfigListConfigServicesHandler == nil {
		unregistered = append(unregistered, "config.ListConfigServicesHandler")
	}
	if o.ConfigListConfigTypesHandler == nil {
		unregistered = append(unregistered, "config.ListConfigTypesHandler")
	}
	if o.ConfigListConfigsHandler == nil {
		unregistered = append(unregistered, "config.ListConfigsHandler")
	}
	if o.ConfigListConfigsForConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.ListConfigsForConfigTypeHandler")
	}
	if o.SettingsListControllerSettingsHandler == nil {
		unregistered = append(unregistered, "settings.ListControllerSettingsHandler")
	}
	if o.ControllersListControllersHandler == nil {
		unregistered = append(unregistered, "controllers.ListControllersHandler")
	}
	if o.CurrentAPISessionListCurrentIdentityAuthenticatorsHandler == nil {
		unregistered = append(unregistered, "current_api_session.ListCurrentIdentityAuthenticatorsHandler")
	}
	if o.EdgeRouterListEdgeRouterEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "edge_router.ListEdgeRouterEdgeRouterPoliciesHandler")
	}
	if o.EdgeRouterListEdgeRouterIdentitiesHandler == nil {
		unregistered = append(unregistered, "edge_router.ListEdgeRouterIdentitiesHandler")
	}
	if o.EdgeRouterPolicyListEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.ListEdgeRouterPoliciesHandler")
	}
	if o.EdgeRouterPolicyListEdgeRouterPolicyEdgeRoutersHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.ListEdgeRouterPolicyEdgeRoutersHandler")
	}
	if o.EdgeRouterPolicyListEdgeRouterPolicyIdentitiesHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.ListEdgeRouterPolicyIdentitiesHandler")
	}
	if o.RoleAttributesListEdgeRouterRoleAttributesHandler == nil {
		unregistered = append(unregistered, "role_attributes.ListEdgeRouterRoleAttributesHandler")
	}
	if o.EdgeRouterListEdgeRouterServiceEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "edge_router.ListEdgeRouterServiceEdgeRouterPoliciesHandler")
	}
	if o.EdgeRouterListEdgeRouterServicesHandler == nil {
		unregistered = append(unregistered, "edge_router.ListEdgeRouterServicesHandler")
	}
	if o.EdgeRouterListEdgeRoutersHandler == nil {
		unregistered = append(unregistered, "edge_router.ListEdgeRoutersHandler")
	}
	if o.EnrollmentListEnrollmentsHandler == nil {
		unregistered = append(unregistered, "enrollment.ListEnrollmentsHandler")
	}
	if o.InformationalListEnumeratedCapabilitiesHandler == nil {
		unregistered = append(unregistered, "informational.ListEnumeratedCapabilitiesHandler")
	}
	if o.ExternalJWTSignerListExternalJWTSignersHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.ListExternalJWTSignersHandler")
	}
	if o.IdentityListIdentitiesHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentitiesHandler")
	}
	if o.IdentityListIdentityEdgeRoutersHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentityEdgeRoutersHandler")
	}
	if o.RoleAttributesListIdentityRoleAttributesHandler == nil {
		unregistered = append(unregistered, "role_attributes.ListIdentityRoleAttributesHandler")
	}
	if o.IdentityListIdentityServicePoliciesHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentityServicePoliciesHandler")
	}
	if o.IdentityListIdentityServicesHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentityServicesHandler")
	}
	if o.IdentityListIdentityTypesHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentityTypesHandler")
	}
	if o.IdentityListIdentitysEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentitysEdgeRouterPoliciesHandler")
	}
	if o.IdentityListIdentitysServiceConfigsHandler == nil {
		unregistered = append(unregistered, "identity.ListIdentitysServiceConfigsHandler")
	}
	if o.EnrollmentListNetworkJWTsHandler == nil {
		unregistered = append(unregistered, "enrollment.ListNetworkJWTsHandler")
	}
	if o.RoleAttributesListPostureCheckRoleAttributesHandler == nil {
		unregistered = append(unregistered, "role_attributes.ListPostureCheckRoleAttributesHandler")
	}
	if o.PostureChecksListPostureCheckTypesHandler == nil {
		unregistered = append(unregistered, "posture_checks.ListPostureCheckTypesHandler")
	}
	if o.PostureChecksListPostureChecksHandler == nil {
		unregistered = append(unregistered, "posture_checks.ListPostureChecksHandler")
	}
	if o.InformationalListRootHandler == nil {
		unregistered = append(unregistered, "informational.ListRootHandler")
	}
	if o.RouterListRoutersHandler == nil {
		unregistered = append(unregistered, "router.ListRoutersHandler")
	}
	if o.ServiceListServiceConfigHandler == nil {
		unregistered = append(unregistered, "service.ListServiceConfigHandler")
	}
	if o.ServiceEdgeRouterPolicyListServiceEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.ListServiceEdgeRouterPoliciesHandler")
	}
	if o.ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyEdgeRoutersHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.ListServiceEdgeRouterPolicyEdgeRoutersHandler")
	}
	if o.ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyServicesHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.ListServiceEdgeRouterPolicyServicesHandler")
	}
	if o.ServiceListServiceEdgeRoutersHandler == nil {
		unregistered = append(unregistered, "service.ListServiceEdgeRoutersHandler")
	}
	if o.ServiceListServiceIdentitiesHandler == nil {
		unregistered = append(unregistered, "service.ListServiceIdentitiesHandler")
	}
	if o.ServicePolicyListServicePoliciesHandler == nil {
		unregistered = append(unregistered, "service_policy.ListServicePoliciesHandler")
	}
	if o.ServicePolicyListServicePolicyIdentitiesHandler == nil {
		unregistered = append(unregistered, "service_policy.ListServicePolicyIdentitiesHandler")
	}
	if o.ServicePolicyListServicePolicyPostureChecksHandler == nil {
		unregistered = append(unregistered, "service_policy.ListServicePolicyPostureChecksHandler")
	}
	if o.ServicePolicyListServicePolicyServicesHandler == nil {
		unregistered = append(unregistered, "service_policy.ListServicePolicyServicesHandler")
	}
	if o.RoleAttributesListServiceRoleAttributesHandler == nil {
		unregistered = append(unregistered, "role_attributes.ListServiceRoleAttributesHandler")
	}
	if o.ServiceListServiceServiceEdgeRouterPoliciesHandler == nil {
		unregistered = append(unregistered, "service.ListServiceServiceEdgeRouterPoliciesHandler")
	}
	if o.ServiceListServiceServicePoliciesHandler == nil {
		unregistered = append(unregistered, "service.ListServiceServicePoliciesHandler")
	}
	if o.ServiceListServiceTerminatorsHandler == nil {
		unregistered = append(unregistered, "service.ListServiceTerminatorsHandler")
	}
	if o.ServiceListServicesHandler == nil {
		unregistered = append(unregistered, "service.ListServicesHandler")
	}
	if o.SessionListSessionsHandler == nil {
		unregistered = append(unregistered, "session.ListSessionsHandler")
	}
	if o.InformationalListSpecsHandler == nil {
		unregistered = append(unregistered, "informational.ListSpecsHandler")
	}
	if o.InformationalListSummaryHandler == nil {
		unregistered = append(unregistered, "informational.ListSummaryHandler")
	}
	if o.TerminatorListTerminatorsHandler == nil {
		unregistered = append(unregistered, "terminator.ListTerminatorsHandler")
	}
	if o.RouterListTransitRoutersHandler == nil {
		unregistered = append(unregistered, "router.ListTransitRoutersHandler")
	}
	if o.InformationalListVersionHandler == nil {
		unregistered = append(unregistered, "informational.ListVersionHandler")
	}
	if o.WellKnownListWellKnownCasHandler == nil {
		unregistered = append(unregistered, "well_known.ListWellKnownCasHandler")
	}
	if o.AuthPolicyPatchAuthPolicyHandler == nil {
		unregistered = append(unregistered, "auth_policy.PatchAuthPolicyHandler")
	}
	if o.AuthenticatorPatchAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.PatchAuthenticatorHandler")
	}
	if o.CertificateAuthorityPatchCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.PatchCaHandler")
	}
	if o.ConfigPatchConfigHandler == nil {
		unregistered = append(unregistered, "config.PatchConfigHandler")
	}
	if o.ConfigPatchConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.PatchConfigTypeHandler")
	}
	if o.SettingsPatchControllerSettingHandler == nil {
		unregistered = append(unregistered, "settings.PatchControllerSettingHandler")
	}
	if o.CurrentAPISessionPatchCurrentIdentityAuthenticatorHandler == nil {
		unregistered = append(unregistered, "current_api_session.PatchCurrentIdentityAuthenticatorHandler")
	}
	if o.EdgeRouterPatchEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.PatchEdgeRouterHandler")
	}
	if o.EdgeRouterPolicyPatchEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.PatchEdgeRouterPolicyHandler")
	}
	if o.ExternalJWTSignerPatchExternalJWTSignerHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.PatchExternalJWTSignerHandler")
	}
	if o.IdentityPatchIdentityHandler == nil {
		unregistered = append(unregistered, "identity.PatchIdentityHandler")
	}
	if o.PostureChecksPatchPostureCheckHandler == nil {
		unregistered = append(unregistered, "posture_checks.PatchPostureCheckHandler")
	}
	if o.RouterPatchRouterHandler == nil {
		unregistered = append(unregistered, "router.PatchRouterHandler")
	}
	if o.ServicePatchServiceHandler == nil {
		unregistered = append(unregistered, "service.PatchServiceHandler")
	}
	if o.ServiceEdgeRouterPolicyPatchServiceEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.PatchServiceEdgeRouterPolicyHandler")
	}
	if o.ServicePolicyPatchServicePolicyHandler == nil {
		unregistered = append(unregistered, "service_policy.PatchServicePolicyHandler")
	}
	if o.TerminatorPatchTerminatorHandler == nil {
		unregistered = append(unregistered, "terminator.PatchTerminatorHandler")
	}
	if o.RouterPatchTransitRouterHandler == nil {
		unregistered = append(unregistered, "router.PatchTransitRouterHandler")
	}
	if o.AuthenticatorReEnrollAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.ReEnrollAuthenticatorHandler")
	}
	if o.EdgeRouterReEnrollEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.ReEnrollEdgeRouterHandler")
	}
	if o.EnrollmentRefreshEnrollmentHandler == nil {
		unregistered = append(unregistered, "enrollment.RefreshEnrollmentHandler")
	}
	if o.IdentityRemoveIdentityMfaHandler == nil {
		unregistered = append(unregistered, "identity.RemoveIdentityMfaHandler")
	}
	if o.AuthenticatorRequestExtendAllCertAuthenticatorsHandler == nil {
		unregistered = append(unregistered, "authenticator.RequestExtendAllCertAuthenticatorsHandler")
	}
	if o.AuthenticatorRequestExtendAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.RequestExtendAuthenticatorHandler")
	}
	if o.AuthPolicyUpdateAuthPolicyHandler == nil {
		unregistered = append(unregistered, "auth_policy.UpdateAuthPolicyHandler")
	}
	if o.AuthenticatorUpdateAuthenticatorHandler == nil {
		unregistered = append(unregistered, "authenticator.UpdateAuthenticatorHandler")
	}
	if o.CertificateAuthorityUpdateCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.UpdateCaHandler")
	}
	if o.ConfigUpdateConfigHandler == nil {
		unregistered = append(unregistered, "config.UpdateConfigHandler")
	}
	if o.ConfigUpdateConfigTypeHandler == nil {
		unregistered = append(unregistered, "config.UpdateConfigTypeHandler")
	}
	if o.SettingsUpdateControllerSettingHandler == nil {
		unregistered = append(unregistered, "settings.UpdateControllerSettingHandler")
	}
	if o.CurrentAPISessionUpdateCurrentIdentityAuthenticatorHandler == nil {
		unregistered = append(unregistered, "current_api_session.UpdateCurrentIdentityAuthenticatorHandler")
	}
	if o.EdgeRouterUpdateEdgeRouterHandler == nil {
		unregistered = append(unregistered, "edge_router.UpdateEdgeRouterHandler")
	}
	if o.EdgeRouterPolicyUpdateEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "edge_router_policy.UpdateEdgeRouterPolicyHandler")
	}
	if o.ExternalJWTSignerUpdateExternalJWTSignerHandler == nil {
		unregistered = append(unregistered, "external_jwt_signer.UpdateExternalJWTSignerHandler")
	}
	if o.IdentityUpdateIdentityHandler == nil {
		unregistered = append(unregistered, "identity.UpdateIdentityHandler")
	}
	if o.IdentityUpdateIdentityTracingHandler == nil {
		unregistered = append(unregistered, "identity.UpdateIdentityTracingHandler")
	}
	if o.PostureChecksUpdatePostureCheckHandler == nil {
		unregistered = append(unregistered, "posture_checks.UpdatePostureCheckHandler")
	}
	if o.RouterUpdateRouterHandler == nil {
		unregistered = append(unregistered, "router.UpdateRouterHandler")
	}
	if o.ServiceUpdateServiceHandler == nil {
		unregistered = append(unregistered, "service.UpdateServiceHandler")
	}
	if o.ServiceEdgeRouterPolicyUpdateServiceEdgeRouterPolicyHandler == nil {
		unregistered = append(unregistered, "service_edge_router_policy.UpdateServiceEdgeRouterPolicyHandler")
	}
	if o.ServicePolicyUpdateServicePolicyHandler == nil {
		unregistered = append(unregistered, "service_policy.UpdateServicePolicyHandler")
	}
	if o.TerminatorUpdateTerminatorHandler == nil {
		unregistered = append(unregistered, "terminator.UpdateTerminatorHandler")
	}
	if o.RouterUpdateTransitRouterHandler == nil {
		unregistered = append(unregistered, "router.UpdateTransitRouterHandler")
	}
	if o.CertificateAuthorityVerifyCaHandler == nil {
		unregistered = append(unregistered, "certificate_authority.VerifyCaHandler")
	}
	if o.CurrentIdentityVerifyMfaHandler == nil {
		unregistered = append(unregistered, "current_identity.VerifyMfaHandler")
	}

	if len(unregistered) > 0 {
		return fmt.Errorf("missing registration: %s", strings.Join(unregistered, ", "))
	}

	return nil
}

// ServeErrorFor gets a error handler for a given operation id
func (o *ZitiEdgeManagementAPI) ServeErrorFor(operationID string) func(http.ResponseWriter, *http.Request, error) {
	return o.ServeError
}

// AuthenticatorsFor gets the authenticators for the specified security schemes
func (o *ZitiEdgeManagementAPI) AuthenticatorsFor(schemes map[string]spec.SecurityScheme) map[string]runtime.Authenticator {
	result := make(map[string]runtime.Authenticator)
	for name := range schemes {
		switch name {
		case "oauth2":
			result[name] = o.BearerAuthenticator(name, o.Oauth2Auth)

		case "ztSession":
			scheme := schemes[name]
			result[name] = o.APIKeyAuthenticator(scheme.Name, scheme.In, o.ZtSessionAuth)

		}
	}

	return result
}

// Authorizer returns the registered authorizer
func (o *ZitiEdgeManagementAPI) Authorizer() runtime.Authorizer {
	return o.APIAuthorizer
}

// ConsumersFor gets the consumers for the specified media types.
//
// MIME type parameters are ignored here.
func (o *ZitiEdgeManagementAPI) ConsumersFor(mediaTypes []string) map[string]runtime.Consumer {
	result := make(map[string]runtime.Consumer, len(mediaTypes))
	for _, mt := range mediaTypes {
		switch mt {
		case "application/json":
			result["application/json"] = o.JSONConsumer
		case "text/plain":
			result["text/plain"] = o.TxtConsumer
		}

		if c, ok := o.customConsumers[mt]; ok {
			result[mt] = c
		}
	}

	return result
}

// ProducersFor gets the producers for the specified media types.
//
// MIME type parameters are ignored here.
func (o *ZitiEdgeManagementAPI) ProducersFor(mediaTypes []string) map[string]runtime.Producer {
	result := make(map[string]runtime.Producer, len(mediaTypes))
	for _, mt := range mediaTypes {
		switch mt {
		case "application/jwt":
			result["application/jwt"] = o.ApplicationJWTProducer
		case "application/pkcs7-mime":
			result["application/pkcs7-mime"] = o.ApplicationPkcs7MimeProducer
		case "image/png":
			result["image/png"] = o.BinProducer
		case "application/json":
			result["application/json"] = o.JSONProducer
		case "text/yaml":
			result["text/yaml"] = o.TextYamlProducer
		}

		if p, ok := o.customProducers[mt]; ok {
			result[mt] = p
		}
	}

	return result
}

// HandlerFor gets a http.Handler for the provided operation method and path
func (o *ZitiEdgeManagementAPI) HandlerFor(method, path string) (http.Handler, bool) {
	if o.handlers == nil {
		return nil, false
	}
	um := strings.ToUpper(method)
	if _, ok := o.handlers[um]; !ok {
		return nil, false
	}
	if path == "/" {
		path = ""
	}
	h, ok := o.handlers[um][path]
	return h, ok
}

// Context returns the middleware context for the zt edge management API
func (o *ZitiEdgeManagementAPI) Context() *middleware.Context {
	if o.context == nil {
		o.context = middleware.NewRoutableContext(o.spec, o, nil)
	}

	return o.context
}

func (o *ZitiEdgeManagementAPI) initHandlerCache() {
	o.Context() // don't care about the result, just that the initialization happened
	if o.handlers == nil {
		o.handlers = make(map[string]map[string]http.Handler)
	}

	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/current-api-session"] = current_api_session.NewDeleteCurrentAPISession(o.context, o.CurrentAPISessionDeleteCurrentAPISessionHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/identities/{id}/service-configs"] = identity.NewAssociateIdentitysServiceConfigs(o.context, o.IdentityAssociateIdentitysServiceConfigsHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/authenticate"] = authentication.NewAuthenticate(o.context, o.AuthenticationAuthenticateHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/authenticate/mfa"] = authentication.NewAuthenticateMfa(o.context, o.AuthenticationAuthenticateMfaHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/database/check-data-integrity"] = database.NewCheckDataIntegrity(o.context, o.DatabaseCheckDataIntegrityHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/auth-policies"] = auth_policy.NewCreateAuthPolicy(o.context, o.AuthPolicyCreateAuthPolicyHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/authenticators"] = authenticator.NewCreateAuthenticator(o.context, o.AuthenticatorCreateAuthenticatorHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/cas"] = certificate_authority.NewCreateCa(o.context, o.CertificateAuthorityCreateCaHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/configs"] = config.NewCreateConfig(o.context, o.ConfigCreateConfigHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/config-types"] = config.NewCreateConfigType(o.context, o.ConfigCreateConfigTypeHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/controller-settings"] = settings.NewCreateControllerSetting(o.context, o.SettingsCreateControllerSettingHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/database/snapshot"] = database.NewCreateDatabaseSnapshot(o.context, o.DatabaseCreateDatabaseSnapshotHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/edge-routers"] = edge_router.NewCreateEdgeRouter(o.context, o.EdgeRouterCreateEdgeRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/edge-router-policies"] = edge_router_policy.NewCreateEdgeRouterPolicy(o.context, o.EdgeRouterPolicyCreateEdgeRouterPolicyHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/enrollments"] = enrollment.NewCreateEnrollment(o.context, o.EnrollmentCreateEnrollmentHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/external-jwt-signers"] = external_jwt_signer.NewCreateExternalJWTSigner(o.context, o.ExternalJWTSignerCreateExternalJWTSignerHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/identities"] = identity.NewCreateIdentity(o.context, o.IdentityCreateIdentityHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-identity/mfa/recovery-codes"] = current_identity.NewCreateMfaRecoveryCodes(o.context, o.CurrentIdentityCreateMfaRecoveryCodesHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/posture-checks"] = posture_checks.NewCreatePostureCheck(o.context, o.PostureChecksCreatePostureCheckHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/routers"] = router.NewCreateRouter(o.context, o.RouterCreateRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/services"] = service.NewCreateService(o.context, o.ServiceCreateServiceHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/service-edge-router-policies"] = service_edge_router_policy.NewCreateServiceEdgeRouterPolicy(o.context, o.ServiceEdgeRouterPolicyCreateServiceEdgeRouterPolicyHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/service-policies"] = service_policy.NewCreateServicePolicy(o.context, o.ServicePolicyCreateServicePolicyHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/terminators"] = terminator.NewCreateTerminator(o.context, o.TerminatorCreateTerminatorHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-api-session/totp-token"] = current_api_session.NewCreateTotpToken(o.context, o.CurrentAPISessionCreateTotpTokenHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/transit-routers"] = router.NewCreateTransitRouter(o.context, o.RouterCreateTransitRouterHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/database/data-integrity-results"] = database.NewDataIntegrityResults(o.context, o.DatabaseDataIntegrityResultsHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/api-sessions/{id}"] = api_session.NewDeleteAPISessions(o.context, o.APISessionDeleteAPISessionsHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/auth-policies/{id}"] = auth_policy.NewDeleteAuthPolicy(o.context, o.AuthPolicyDeleteAuthPolicyHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/authenticators/{id}"] = authenticator.NewDeleteAuthenticator(o.context, o.AuthenticatorDeleteAuthenticatorHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/cas/{id}"] = certificate_authority.NewDeleteCa(o.context, o.CertificateAuthorityDeleteCaHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/configs/{id}"] = config.NewDeleteConfig(o.context, o.ConfigDeleteConfigHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/config-types/{id}"] = config.NewDeleteConfigType(o.context, o.ConfigDeleteConfigTypeHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/controller-settings/{id}/effective"] = settings.NewDeleteControllerSetting(o.context, o.SettingsDeleteControllerSettingHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/edge-routers/{id}"] = edge_router.NewDeleteEdgeRouter(o.context, o.EdgeRouterDeleteEdgeRouterHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/edge-router-policies/{id}"] = edge_router_policy.NewDeleteEdgeRouterPolicy(o.context, o.EdgeRouterPolicyDeleteEdgeRouterPolicyHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/enrollments/{id}"] = enrollment.NewDeleteEnrollment(o.context, o.EnrollmentDeleteEnrollmentHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/external-jwt-signers/{id}"] = external_jwt_signer.NewDeleteExternalJWTSigner(o.context, o.ExternalJWTSignerDeleteExternalJWTSignerHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/identities/{id}"] = identity.NewDeleteIdentity(o.context, o.IdentityDeleteIdentityHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/current-identity/mfa"] = current_identity.NewDeleteMfa(o.context, o.CurrentIdentityDeleteMfaHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/posture-checks/{id}"] = posture_checks.NewDeletePostureCheck(o.context, o.PostureChecksDeletePostureCheckHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/routers/{id}"] = router.NewDeleteRouter(o.context, o.RouterDeleteRouterHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/services/{id}"] = service.NewDeleteService(o.context, o.ServiceDeleteServiceHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/service-edge-router-policies/{id}"] = service_edge_router_policy.NewDeleteServiceEdgeRouterPolicy(o.context, o.ServiceEdgeRouterPolicyDeleteServiceEdgeRouterPolicyHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/service-policies/{id}"] = service_policy.NewDeleteServicePolicy(o.context, o.ServicePolicyDeleteServicePolicyHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/sessions/{id}"] = session.NewDeleteSession(o.context, o.SessionDeleteSessionHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/terminators/{id}"] = terminator.NewDeleteTerminator(o.context, o.TerminatorDeleteTerminatorHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/transit-routers/{id}"] = router.NewDeleteTransitRouter(o.context, o.RouterDeleteTransitRouterHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/api-sessions/{id}"] = api_session.NewDetailAPISessions(o.context, o.APISessionDetailAPISessionsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/auth-policies/{id}"] = auth_policy.NewDetailAuthPolicy(o.context, o.AuthPolicyDetailAuthPolicyHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/authenticators/{id}"] = authenticator.NewDetailAuthenticator(o.context, o.AuthenticatorDetailAuthenticatorHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/cas/{id}"] = certificate_authority.NewDetailCa(o.context, o.CertificateAuthorityDetailCaHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/configs/{id}"] = config.NewDetailConfig(o.context, o.ConfigDetailConfigHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/config-types/{id}"] = config.NewDetailConfigType(o.context, o.ConfigDetailConfigTypeHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/controller-settings/{id}"] = settings.NewDetailControllerSetting(o.context, o.SettingsDetailControllerSettingHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/controller-settings/{id}/effective"] = settings.NewDetailControllerSettingEffective(o.context, o.SettingsDetailControllerSettingEffectiveHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity/authenticators/{id}"] = current_api_session.NewDetailCurrentIdentityAuthenticator(o.context, o.CurrentAPISessionDetailCurrentIdentityAuthenticatorHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers/{id}"] = edge_router.NewDetailEdgeRouter(o.context, o.EdgeRouterDetailEdgeRouterHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-router-policies/{id}"] = edge_router_policy.NewDetailEdgeRouterPolicy(o.context, o.EdgeRouterPolicyDetailEdgeRouterPolicyHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/enrollments/{id}"] = enrollment.NewDetailEnrollment(o.context, o.EnrollmentDetailEnrollmentHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/external-jwt-signers/{id}"] = external_jwt_signer.NewDetailExternalJWTSigner(o.context, o.ExternalJWTSignerDetailExternalJWTSignerHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}"] = identity.NewDetailIdentity(o.context, o.IdentityDetailIdentityHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identity-types/{id}"] = identity.NewDetailIdentityType(o.context, o.IdentityDetailIdentityTypeHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity/mfa"] = current_identity.NewDetailMfa(o.context, o.CurrentIdentityDetailMfaHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity/mfa/qr-code"] = current_identity.NewDetailMfaQrCode(o.context, o.CurrentIdentityDetailMfaQrCodeHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity/mfa/recovery-codes"] = current_identity.NewDetailMfaRecoveryCodes(o.context, o.CurrentIdentityDetailMfaRecoveryCodesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/posture-checks/{id}"] = posture_checks.NewDetailPostureCheck(o.context, o.PostureChecksDetailPostureCheckHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/posture-check-types/{id}"] = posture_checks.NewDetailPostureCheckType(o.context, o.PostureChecksDetailPostureCheckTypeHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/routers/{id}"] = router.NewDetailRouter(o.context, o.RouterDetailRouterHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}"] = service.NewDetailService(o.context, o.ServiceDetailServiceHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-edge-router-policies/{id}"] = service_edge_router_policy.NewDetailServiceEdgeRouterPolicy(o.context, o.ServiceEdgeRouterPolicyDetailServiceEdgeRouterPolicyHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-policies/{id}"] = service_policy.NewDetailServicePolicy(o.context, o.ServicePolicyDetailServicePolicyHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/sessions/{id}"] = session.NewDetailSession(o.context, o.SessionDetailSessionHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/sessions/{id}/route-path"] = session.NewDetailSessionRoutePath(o.context, o.SessionDetailSessionRoutePathHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/specs/{id}"] = informational.NewDetailSpec(o.context, o.InformationalDetailSpecHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/specs/{id}/spec"] = informational.NewDetailSpecBody(o.context, o.InformationalDetailSpecBodyHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/terminators/{id}"] = terminator.NewDetailTerminator(o.context, o.TerminatorDetailTerminatorHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/transit-routers/{id}"] = router.NewDetailTransitRouter(o.context, o.RouterDetailTransitRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/identities/{id}/disable"] = identity.NewDisableIdentity(o.context, o.IdentityDisableIdentityHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/identities/{id}/service-configs"] = identity.NewDisassociateIdentitysServiceConfigs(o.context, o.IdentityDisassociateIdentitysServiceConfigsHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/identities/{id}/enable"] = identity.NewEnableIdentity(o.context, o.IdentityEnableIdentityHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-identity/mfa"] = current_identity.NewEnrollMfa(o.context, o.CurrentIdentityEnrollMfaHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-identity/authenticators/{id}/extend"] = current_api_session.NewExtendCurrentIdentityAuthenticator(o.context, o.CurrentAPISessionExtendCurrentIdentityAuthenticatorHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-identity/authenticators/{id}/extend-verify"] = current_api_session.NewExtendVerifyCurrentIdentityAuthenticator(o.context, o.CurrentAPISessionExtendVerifyCurrentIdentityAuthenticatorHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/database/fix-data-integrity"] = database.NewFixDataIntegrity(o.context, o.DatabaseFixDataIntegrityHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/cas/{id}/jwt"] = certificate_authority.NewGetCaJWT(o.context, o.CertificateAuthorityGetCaJWTHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-api-session"] = current_api_session.NewGetCurrentAPISession(o.context, o.CurrentAPISessionGetCurrentAPISessionHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity"] = current_identity.NewGetCurrentIdentity(o.context, o.CurrentIdentityGetCurrentIdentityHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/authenticators"] = identity.NewGetIdentityAuthenticators(o.context, o.IdentityGetIdentityAuthenticatorsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/enrollments"] = identity.NewGetIdentityEnrollments(o.context, o.IdentityGetIdentityEnrollmentsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/failed-service-requests"] = identity.NewGetIdentityFailedServiceRequests(o.context, o.IdentityGetIdentityFailedServiceRequestsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/policy-advice/{serviceId}"] = identity.NewGetIdentityPolicyAdvice(o.context, o.IdentityGetIdentityPolicyAdviceHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/posture-data"] = identity.NewGetIdentityPostureData(o.context, o.IdentityGetIdentityPostureDataHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/api-sessions"] = api_session.NewListAPISessions(o.context, o.APISessionListAPISessionsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/auth-policies"] = auth_policy.NewListAuthPolicies(o.context, o.AuthPolicyListAuthPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/authenticators"] = authenticator.NewListAuthenticators(o.context, o.AuthenticatorListAuthenticatorsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/cas"] = certificate_authority.NewListCas(o.context, o.CertificateAuthorityListCasHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/configs/{id}/services"] = config.NewListConfigServices(o.context, o.ConfigListConfigServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/config-types"] = config.NewListConfigTypes(o.context, o.ConfigListConfigTypesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/configs"] = config.NewListConfigs(o.context, o.ConfigListConfigsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/config-types/{id}/configs"] = config.NewListConfigsForConfigType(o.context, o.ConfigListConfigsForConfigTypeHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/controller-settings"] = settings.NewListControllerSettings(o.context, o.SettingsListControllerSettingsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/controllers"] = controllers.NewListControllers(o.context, o.ControllersListControllersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/current-identity/authenticators"] = current_api_session.NewListCurrentIdentityAuthenticators(o.context, o.CurrentAPISessionListCurrentIdentityAuthenticatorsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers/{id}/edge-router-policies"] = edge_router.NewListEdgeRouterEdgeRouterPolicies(o.context, o.EdgeRouterListEdgeRouterEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers/{id}/identities"] = edge_router.NewListEdgeRouterIdentities(o.context, o.EdgeRouterListEdgeRouterIdentitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-router-policies"] = edge_router_policy.NewListEdgeRouterPolicies(o.context, o.EdgeRouterPolicyListEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-router-policies/{id}/edge-routers"] = edge_router_policy.NewListEdgeRouterPolicyEdgeRouters(o.context, o.EdgeRouterPolicyListEdgeRouterPolicyEdgeRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-router-policies/{id}/identities"] = edge_router_policy.NewListEdgeRouterPolicyIdentities(o.context, o.EdgeRouterPolicyListEdgeRouterPolicyIdentitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-router-role-attributes"] = role_attributes.NewListEdgeRouterRoleAttributes(o.context, o.RoleAttributesListEdgeRouterRoleAttributesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers/{id}/service-edge-router-policies"] = edge_router.NewListEdgeRouterServiceEdgeRouterPolicies(o.context, o.EdgeRouterListEdgeRouterServiceEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers/{id}/services"] = edge_router.NewListEdgeRouterServices(o.context, o.EdgeRouterListEdgeRouterServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/edge-routers"] = edge_router.NewListEdgeRouters(o.context, o.EdgeRouterListEdgeRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/enrollments"] = enrollment.NewListEnrollments(o.context, o.EnrollmentListEnrollmentsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/enumerated-capabilities"] = informational.NewListEnumeratedCapabilities(o.context, o.InformationalListEnumeratedCapabilitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/external-jwt-signers"] = external_jwt_signer.NewListExternalJWTSigners(o.context, o.ExternalJWTSignerListExternalJWTSignersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities"] = identity.NewListIdentities(o.context, o.IdentityListIdentitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/edge-routers"] = identity.NewListIdentityEdgeRouters(o.context, o.IdentityListIdentityEdgeRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identity-role-attributes"] = role_attributes.NewListIdentityRoleAttributes(o.context, o.RoleAttributesListIdentityRoleAttributesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/service-policies"] = identity.NewListIdentityServicePolicies(o.context, o.IdentityListIdentityServicePoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/services"] = identity.NewListIdentityServices(o.context, o.IdentityListIdentityServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identity-types"] = identity.NewListIdentityTypes(o.context, o.IdentityListIdentityTypesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/edge-router-policies"] = identity.NewListIdentitysEdgeRouterPolicies(o.context, o.IdentityListIdentitysEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/identities/{id}/service-configs"] = identity.NewListIdentitysServiceConfigs(o.context, o.IdentityListIdentitysServiceConfigsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/network-jwts"] = enrollment.NewListNetworkJWTs(o.context, o.EnrollmentListNetworkJWTsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/posture-check-role-attributes"] = role_attributes.NewListPostureCheckRoleAttributes(o.context, o.RoleAttributesListPostureCheckRoleAttributesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/posture-check-types"] = posture_checks.NewListPostureCheckTypes(o.context, o.PostureChecksListPostureCheckTypesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/posture-checks"] = posture_checks.NewListPostureChecks(o.context, o.PostureChecksListPostureChecksHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"][""] = informational.NewListRoot(o.context, o.InformationalListRootHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/routers"] = router.NewListRouters(o.context, o.RouterListRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/configs"] = service.NewListServiceConfig(o.context, o.ServiceListServiceConfigHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-edge-router-policies"] = service_edge_router_policy.NewListServiceEdgeRouterPolicies(o.context, o.ServiceEdgeRouterPolicyListServiceEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-edge-router-policies/{id}/edge-routers"] = service_edge_router_policy.NewListServiceEdgeRouterPolicyEdgeRouters(o.context, o.ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyEdgeRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-edge-router-policies/{id}/services"] = service_edge_router_policy.NewListServiceEdgeRouterPolicyServices(o.context, o.ServiceEdgeRouterPolicyListServiceEdgeRouterPolicyServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/edge-routers"] = service.NewListServiceEdgeRouters(o.context, o.ServiceListServiceEdgeRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/identities"] = service.NewListServiceIdentities(o.context, o.ServiceListServiceIdentitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-policies"] = service_policy.NewListServicePolicies(o.context, o.ServicePolicyListServicePoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-policies/{id}/identities"] = service_policy.NewListServicePolicyIdentities(o.context, o.ServicePolicyListServicePolicyIdentitiesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-policies/{id}/posture-checks"] = service_policy.NewListServicePolicyPostureChecks(o.context, o.ServicePolicyListServicePolicyPostureChecksHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-policies/{id}/services"] = service_policy.NewListServicePolicyServices(o.context, o.ServicePolicyListServicePolicyServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/service-role-attributes"] = role_attributes.NewListServiceRoleAttributes(o.context, o.RoleAttributesListServiceRoleAttributesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/service-edge-router-policies"] = service.NewListServiceServiceEdgeRouterPolicies(o.context, o.ServiceListServiceServiceEdgeRouterPoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/service-policies"] = service.NewListServiceServicePolicies(o.context, o.ServiceListServiceServicePoliciesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services/{id}/terminators"] = service.NewListServiceTerminators(o.context, o.ServiceListServiceTerminatorsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/services"] = service.NewListServices(o.context, o.ServiceListServicesHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/sessions"] = session.NewListSessions(o.context, o.SessionListSessionsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/specs"] = informational.NewListSpecs(o.context, o.InformationalListSpecsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/summary"] = informational.NewListSummary(o.context, o.InformationalListSummaryHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/terminators"] = terminator.NewListTerminators(o.context, o.TerminatorListTerminatorsHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/transit-routers"] = router.NewListTransitRouters(o.context, o.RouterListTransitRoutersHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/version"] = informational.NewListVersion(o.context, o.InformationalListVersionHandler)
	if o.handlers["GET"] == nil {
		o.handlers["GET"] = make(map[string]http.Handler)
	}
	o.handlers["GET"]["/.well-known/est/cacerts"] = well_known.NewListWellKnownCas(o.context, o.WellKnownListWellKnownCasHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/auth-policies/{id}"] = auth_policy.NewPatchAuthPolicy(o.context, o.AuthPolicyPatchAuthPolicyHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/authenticators/{id}"] = authenticator.NewPatchAuthenticator(o.context, o.AuthenticatorPatchAuthenticatorHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/cas/{id}"] = certificate_authority.NewPatchCa(o.context, o.CertificateAuthorityPatchCaHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/configs/{id}"] = config.NewPatchConfig(o.context, o.ConfigPatchConfigHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/config-types/{id}"] = config.NewPatchConfigType(o.context, o.ConfigPatchConfigTypeHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/controller-settings/{id}/effective"] = settings.NewPatchControllerSetting(o.context, o.SettingsPatchControllerSettingHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/current-identity/authenticators/{id}"] = current_api_session.NewPatchCurrentIdentityAuthenticator(o.context, o.CurrentAPISessionPatchCurrentIdentityAuthenticatorHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/edge-routers/{id}"] = edge_router.NewPatchEdgeRouter(o.context, o.EdgeRouterPatchEdgeRouterHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/edge-router-policies/{id}"] = edge_router_policy.NewPatchEdgeRouterPolicy(o.context, o.EdgeRouterPolicyPatchEdgeRouterPolicyHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/external-jwt-signers/{id}"] = external_jwt_signer.NewPatchExternalJWTSigner(o.context, o.ExternalJWTSignerPatchExternalJWTSignerHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/identities/{id}"] = identity.NewPatchIdentity(o.context, o.IdentityPatchIdentityHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/posture-checks/{id}"] = posture_checks.NewPatchPostureCheck(o.context, o.PostureChecksPatchPostureCheckHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/routers/{id}"] = router.NewPatchRouter(o.context, o.RouterPatchRouterHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/services/{id}"] = service.NewPatchService(o.context, o.ServicePatchServiceHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/service-edge-router-policies/{id}"] = service_edge_router_policy.NewPatchServiceEdgeRouterPolicy(o.context, o.ServiceEdgeRouterPolicyPatchServiceEdgeRouterPolicyHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/service-policies/{id}"] = service_policy.NewPatchServicePolicy(o.context, o.ServicePolicyPatchServicePolicyHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/terminators/{id}"] = terminator.NewPatchTerminator(o.context, o.TerminatorPatchTerminatorHandler)
	if o.handlers["PATCH"] == nil {
		o.handlers["PATCH"] = make(map[string]http.Handler)
	}
	o.handlers["PATCH"]["/transit-routers/{id}"] = router.NewPatchTransitRouter(o.context, o.RouterPatchTransitRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/authenticators/{id}/re-enroll"] = authenticator.NewReEnrollAuthenticator(o.context, o.AuthenticatorReEnrollAuthenticatorHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/edge-routers/{id}/re-enroll"] = edge_router.NewReEnrollEdgeRouter(o.context, o.EdgeRouterReEnrollEdgeRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/enrollments/{id}/refresh"] = enrollment.NewRefreshEnrollment(o.context, o.EnrollmentRefreshEnrollmentHandler)
	if o.handlers["DELETE"] == nil {
		o.handlers["DELETE"] = make(map[string]http.Handler)
	}
	o.handlers["DELETE"]["/identities/{id}/mfa"] = identity.NewRemoveIdentityMfa(o.context, o.IdentityRemoveIdentityMfaHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/identities/{id}/request-extend"] = authenticator.NewRequestExtendAllCertAuthenticators(o.context, o.AuthenticatorRequestExtendAllCertAuthenticatorsHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/authenticators/{id}/request-extend"] = authenticator.NewRequestExtendAuthenticator(o.context, o.AuthenticatorRequestExtendAuthenticatorHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/auth-policies/{id}"] = auth_policy.NewUpdateAuthPolicy(o.context, o.AuthPolicyUpdateAuthPolicyHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/authenticators/{id}"] = authenticator.NewUpdateAuthenticator(o.context, o.AuthenticatorUpdateAuthenticatorHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/cas/{id}"] = certificate_authority.NewUpdateCa(o.context, o.CertificateAuthorityUpdateCaHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/configs/{id}"] = config.NewUpdateConfig(o.context, o.ConfigUpdateConfigHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/config-types/{id}"] = config.NewUpdateConfigType(o.context, o.ConfigUpdateConfigTypeHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/controller-settings/{id}/effective"] = settings.NewUpdateControllerSetting(o.context, o.SettingsUpdateControllerSettingHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/current-identity/authenticators/{id}"] = current_api_session.NewUpdateCurrentIdentityAuthenticator(o.context, o.CurrentAPISessionUpdateCurrentIdentityAuthenticatorHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/edge-routers/{id}"] = edge_router.NewUpdateEdgeRouter(o.context, o.EdgeRouterUpdateEdgeRouterHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/edge-router-policies/{id}"] = edge_router_policy.NewUpdateEdgeRouterPolicy(o.context, o.EdgeRouterPolicyUpdateEdgeRouterPolicyHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/external-jwt-signers/{id}"] = external_jwt_signer.NewUpdateExternalJWTSigner(o.context, o.ExternalJWTSignerUpdateExternalJWTSignerHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/identities/{id}"] = identity.NewUpdateIdentity(o.context, o.IdentityUpdateIdentityHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/identities/{id}/trace"] = identity.NewUpdateIdentityTracing(o.context, o.IdentityUpdateIdentityTracingHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/posture-checks/{id}"] = posture_checks.NewUpdatePostureCheck(o.context, o.PostureChecksUpdatePostureCheckHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/routers/{id}"] = router.NewUpdateRouter(o.context, o.RouterUpdateRouterHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/services/{id}"] = service.NewUpdateService(o.context, o.ServiceUpdateServiceHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/service-edge-router-policies/{id}"] = service_edge_router_policy.NewUpdateServiceEdgeRouterPolicy(o.context, o.ServiceEdgeRouterPolicyUpdateServiceEdgeRouterPolicyHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/service-policies/{id}"] = service_policy.NewUpdateServicePolicy(o.context, o.ServicePolicyUpdateServicePolicyHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/terminators/{id}"] = terminator.NewUpdateTerminator(o.context, o.TerminatorUpdateTerminatorHandler)
	if o.handlers["PUT"] == nil {
		o.handlers["PUT"] = make(map[string]http.Handler)
	}
	o.handlers["PUT"]["/transit-routers/{id}"] = router.NewUpdateTransitRouter(o.context, o.RouterUpdateTransitRouterHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/cas/{id}/verify"] = certificate_authority.NewVerifyCa(o.context, o.CertificateAuthorityVerifyCaHandler)
	if o.handlers["POST"] == nil {
		o.handlers["POST"] = make(map[string]http.Handler)
	}
	o.handlers["POST"]["/current-identity/mfa/verify"] = current_identity.NewVerifyMfa(o.context, o.CurrentIdentityVerifyMfaHandler)
}

// Serve creates a http handler to serve the API over HTTP
// can be used directly in http.ListenAndServe(":8000", api.Serve(nil))
func (o *ZitiEdgeManagementAPI) Serve(builder middleware.Builder) http.Handler {
	o.Init()

	if o.Middleware != nil {
		return o.Middleware(builder)
	}
	if o.useSwaggerUI {
		return o.context.APIHandlerSwaggerUI(builder)
	}
	return o.context.APIHandler(builder)
}

// Init allows you to just initialize the handler cache, you can then recompose the middleware as you see fit
func (o *ZitiEdgeManagementAPI) Init() {
	if len(o.handlers) == 0 {
		o.initHandlerCache()
	}
}

// RegisterConsumer allows you to add (or override) a consumer for a media type.
func (o *ZitiEdgeManagementAPI) RegisterConsumer(mediaType string, consumer runtime.Consumer) {
	o.customConsumers[mediaType] = consumer
}

// RegisterProducer allows you to add (or override) a producer for a media type.
func (o *ZitiEdgeManagementAPI) RegisterProducer(mediaType string, producer runtime.Producer) {
	o.customProducers[mediaType] = producer
}

// AddMiddlewareFor adds a http middleware to existing handler
func (o *ZitiEdgeManagementAPI) AddMiddlewareFor(method, path string, builder middleware.Builder) {
	um := strings.ToUpper(method)
	if path == "/" {
		path = ""
	}
	o.Init()
	if h, ok := o.handlers[um][path]; ok {
		o.handlers[um][path] = builder(h)
	}
}