generated.go

// Package iam provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.4.1 DO NOT EDIT.
package iam

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"

	"github.com/labstack/echo/v4"
	"github.com/oapi-codegen/runtime"
	strictecho "github.com/oapi-codegen/runtime/strictmiddleware/echo"
)

const (
	JwtBearerAuthScopes = "jwtBearerAuth.Scopes"
)

// Defines values for ServiceAccessTokenRequestTokenType.
const (
	ServiceAccessTokenRequestTokenTypeBearer ServiceAccessTokenRequestTokenType = "Bearer"
	ServiceAccessTokenRequestTokenTypeDPoP   ServiceAccessTokenRequestTokenType = "DPoP"
)

// Defines values for UserAccessTokenRequestTokenType.
const (
	UserAccessTokenRequestTokenTypeBearer UserAccessTokenRequestTokenType = "Bearer"
	UserAccessTokenRequestTokenTypeDPoP   UserAccessTokenRequestTokenType = "DPoP"
)

// DPoPRequest defines model for DPoPRequest.
type DPoPRequest struct {
	// Htm The HTTP method for which the DPoP proof is requested.
	Htm string `json:"htm"`

	// Htu The URL for which the DPoP proof is requested. Query params and fragments are ignored during validation.
	Htu string `json:"htu"`

	// Token The access token for which the DPoP proof is requested.
	Token string `json:"token"`
}

// DPoPResponse defines model for DPoPResponse.
type DPoPResponse struct {
	// Dpop The DPoP proof as specified by https://datatracker.ietf.org/doc/html/rfc9449 for resource requests
	Dpop string `json:"dpop"`
}

// DPoPValidateRequest defines model for DPoPValidateRequest.
type DPoPValidateRequest struct {
	// DpopProof The DPoP Proof as specified by https://datatracker.ietf.org/doc/html/rfc9449 for resource requests
	DpopProof string `json:"dpop_proof"`

	// Method The HTTP method against which the DPoP proof is validated.
	Method string `json:"method"`

	// Thumbprint The thumbprint of the public key used to sign the DPoP proof. Base64url encoded, no padding.
	Thumbprint string `json:"thumbprint"`

	// Token The access token against which the DPoP proof is validated.
	Token string `json:"token"`

	// Url The URL against which the DPoP proof is validated. Query params and fragments are ignored during validation.
	Url string `json:"url"`
}

// DPoPValidateResponse defines model for DPoPValidateResponse.
type DPoPValidateResponse struct {
	// Reason The reason why the DPoP Proof header is invalid.
	Reason *string `json:"reason,omitempty"`

	// Valid True if the DPoP Proof header is valid for the access token and HTTP request, false if it is not.
	Valid bool `json:"valid"`
}

// ExtendedTokenIntrospectionResponse defines model for ExtendedTokenIntrospectionResponse.
type ExtendedTokenIntrospectionResponse struct {
	// Active True if the token is active, false if the token is expired, malformed etc. Required per RFC7662
	Active bool `json:"active"`

	// Aud RFC7662 - Service-specific string identifier or list of string identifiers representing the intended audience for this token, as defined in JWT [RFC7519].
	Aud *string `json:"aud,omitempty"`

	// ClientId The client identity the access token was issued to. Since the Verifiable Presentation is used to grant access, the client_id reflects the client_id in the access token request.
	ClientId *string `json:"client_id,omitempty"`

	// Cnf The 'confirmation' claim is used in JWTs to proof the possession of a key.
	Cnf *Cnf `json:"cnf,omitempty"`

	// Exp Expiration date in seconds since UNIX epoch
	Exp *int `json:"exp,omitempty"`

	// Iat Issuance time in seconds since UNIX epoch
	Iat *int `json:"iat,omitempty"`

	// Iss Issuer URL of the authorizer.
	Iss *string `json:"iss,omitempty"`

	// PresentationDefinitions Presentation Definitions, as described in Presentation Exchange specification, fulfilled to obtain the access token
	// The map key is the wallet owner (user/organization)
	PresentationDefinitions *RequiredPresentationDefinitions `json:"presentation_definitions,omitempty"`

	// PresentationSubmissions Mapping of Presentation Definition IDs that were fulfilled to Presentation Submissions.
	PresentationSubmissions *map[string]PresentationSubmission `json:"presentation_submissions,omitempty"`

	// Scope granted scopes
	Scope                *string                   `json:"scope,omitempty"`
	Vps                  *[]VerifiablePresentation `json:"vps,omitempty"`
	AdditionalProperties map[string]interface{}    `json:"-"`
}

// OpenIDConfiguration OpenID entity configuration
// Contain properties from several specifications and may grow over time
type OpenIDConfiguration = map[string]interface{}

// RedirectResponseWithID defines model for RedirectResponseWithID.
type RedirectResponseWithID struct {
	// RedirectUri The URL to which the user-agent will be redirected after the authorization request.
	RedirectUri string `json:"redirect_uri"`

	// SessionId The session ID that can be used to retrieve the access token by the calling application.
	SessionId string `json:"session_id"`
}

// RequestObjectResponse A JSON Web Token (JWT) whose JWT Claims Set holds the JSON-encoded OAuth 2.0 authorization request parameters.
type RequestObjectResponse = string

// ServiceAccessTokenRequest Request for an access token for a service.
type ServiceAccessTokenRequest struct {
	// AuthorizationServer The OAuth Authorization Server's identifier as specified in RFC 8414 (section 2),
	// used to locate the OAuth2 Authorization Server metadata.
	AuthorizationServer string `json:"authorization_server"`

	// Credentials Additional credentials to present (if required by the authorizer), in addition to those in the requester's wallet.
	// They must be in the form of a Verifiable Credential in JSON form.
	// The serialized form (JWT or JSON-LD) in the resulting Verifiable Presentation depends on the capability of the authorizing party.
	// A typical use case is to provide a self-attested credential to convey information about the user that initiated the request.
	//
	// The following credential fields are automatically filled (when not present), and may be omitted:
	// - issuer, credentialSubject.id (MUST be omitted; filled with the DID of the requester)
	// - issuanceDate (filled with the current date/time)
	// - id (filled with a UUID)
	// - proof/signature (MUST be omitted; integrity protection is covered by the VP's proof/signature)
	Credentials *[]VerifiableCredential `json:"credentials,omitempty"`

	// IdToken An optional ID Token (JWT) that represents the end-user.
	// This ID token is included in the Verifiable Presentation that is used to request the access token.
	IdToken *string `json:"id_token,omitempty"`

	// Scope The scope that will be the service for which this access token can be used.
	Scope string `json:"scope"`

	// TokenType The type of access token that is preferred, default: DPoP
	TokenType *ServiceAccessTokenRequestTokenType `json:"token_type,omitempty"`
}

// ServiceAccessTokenRequestTokenType The type of access token that is preferred, default: DPoP
type ServiceAccessTokenRequestTokenType string

// TokenIntrospectionRequest Token introspection request as described in RFC7662 section 2.1
// Alongside the defined properties, it can return values (additionalProperties) from the Verifiable Credentials that resulted from the Presentation Exchange.
type TokenIntrospectionRequest struct {
	Token string `json:"token"`
}

// UserAccessTokenRequest Request for an access token for a user.
type UserAccessTokenRequest struct {
	// AuthorizationServer The OAuth Authorization Server's identifier as specified in RFC 8414 (section 2),
	// used to locate the OAuth2 Authorization Server metadata.
	AuthorizationServer string `json:"authorization_server"`

	// PreauthorizedUser Claims about the authorized user.
	PreauthorizedUser *UserDetails `json:"preauthorized_user,omitempty"`

	// RedirectUri The URL to which the user-agent will be redirected after the authorization request.
	// This is the URL of the calling application.
	// The OAuth2 flow will finish at the /callback URL of the node and the node will redirect the user to this redirect_uri.
	RedirectUri string `json:"redirect_uri"`

	// Scope The scope that will be the service for which this access token can be used.
	Scope string `json:"scope"`

	// TokenType The type of access token that is prefered. Supported values: [Bearer, DPoP], default: DPoP
	TokenType *UserAccessTokenRequestTokenType `json:"token_type,omitempty"`
}

// UserAccessTokenRequestTokenType The type of access token that is prefered. Supported values: [Bearer, DPoP], default: DPoP
type UserAccessTokenRequestTokenType string

// UserDetails Claims about the authorized user.
type UserDetails struct {
	// Id Machine-readable identifier, uniquely identifying the user in the issuing system.
	Id string `json:"id"`

	// Name Human-readable name of the user.
	Name string `json:"name"`

	// Role Role of the user.
	Role string `json:"role"`
}

// Cnf The 'confirmation' claim is used in JWTs to proof the possession of a key.
type Cnf struct {
	// Jkt JWK thumbprint
	Jkt string `json:"jkt"`
}

// RequestOpenid4VCICredentialIssuanceJSONBody defines parameters for RequestOpenid4VCICredentialIssuance.
type RequestOpenid4VCICredentialIssuanceJSONBody struct {
	AuthorizationDetails []map[string]interface{} `json:"authorization_details"`

	// Issuer The OAuth Authorization Server's identifier, that issues the Verifiable Credentials, as specified in RFC 8414 (section 2),
	// used to locate the OAuth2 Authorization Server metadata.
	Issuer string `json:"issuer"`

	// RedirectUri The URL to which the user-agent will be redirected after the authorization request.
	RedirectUri string `json:"redirect_uri"`

	// WalletDid The DID to which the Verifiable Credential must be issued. Must be owned by the given subject.
	WalletDid string `json:"wallet_did"`
}

// RequestServiceAccessTokenParams defines parameters for RequestServiceAccessToken.
type RequestServiceAccessTokenParams struct {
	// CacheControl Access tokens are cached by the Nuts node, specify Cache-Control: no-cache to bypass the cache.
	// This forces the Nuts node to request a new access token from the authorizer.
	//
	// A valid use case for this is when the Resource Server rejects the access token with 401 Unauthorized.
	// It could be that the Authorization Server lost the access token due to a server restart,
	// in combination with (non-recommended) usage of in-memory session storage.
	// The local Nuts node then still considers the token valid, while the Authorization Server does not.
	//
	// Note that this should not be used under normal circumstances, as it will increase round trip time and load on both the requester and authorizer.
	CacheControl *string `json:"Cache-Control,omitempty"`
}

// HandleAuthorizeRequestParams defines parameters for HandleAuthorizeRequest.
type HandleAuthorizeRequestParams struct {
	Params *map[string]string `form:"params,omitempty" json:"params,omitempty"`
}

// CallbackParams defines parameters for Callback.
type CallbackParams struct {
	// Code The authorization code received from the authorization server.
	Code *string `form:"code,omitempty" json:"code,omitempty"`

	// State The client state.
	State *string `form:"state,omitempty" json:"state,omitempty"`

	// Error The error code.
	Error *string `form:"error,omitempty" json:"error,omitempty"`

	// ErrorDescription The error description.
	ErrorDescription *string `form:"error_description,omitempty" json:"error_description,omitempty"`
}

// PresentationDefinitionParams defines parameters for PresentationDefinition.
type PresentationDefinitionParams struct {
	Scope           string           `form:"scope" json:"scope"`
	WalletOwnerType *WalletOwnerType `form:"wallet_owner_type,omitempty" json:"wallet_owner_type,omitempty"`
}

// RequestJWTByPostFormdataBody defines parameters for RequestJWTByPost.
type RequestJWTByPostFormdataBody struct {
	// WalletMetadata OAuth2 Authorization Server Metadata
	// Contain properties from several specifications and may grow over time
	WalletMetadata *OAuthAuthorizationServerMetadata `form:"wallet_metadata,omitempty" json:"wallet_metadata,omitempty"`

	// WalletNonce A String value used to mitigate replay attacks of the Authorization Request.
	// When received, the Verifier MUST use it as the wallet_nonce value in the signed authorization request object.
	WalletNonce *string `form:"wallet_nonce,omitempty" json:"wallet_nonce,omitempty"`
}

// HandleAuthorizeResponseFormdataBody defines parameters for HandleAuthorizeResponse.
type HandleAuthorizeResponseFormdataBody struct {
	// Error error code as defined by the OAuth2 specification
	Error *string `form:"error,omitempty" json:"error,omitempty"`

	// ErrorDescription error description as defined by the OAuth2 specification
	ErrorDescription       *string `form:"error_description,omitempty" json:"error_description,omitempty"`
	PresentationSubmission *string `form:"presentation_submission,omitempty" json:"presentation_submission,omitempty"`

	// State the client state for the verifier
	State *string `form:"state,omitempty" json:"state,omitempty"`

	// VpToken A Verifiable Presentation in either JSON-LD or JWT format.
	VpToken *string `form:"vp_token,omitempty" json:"vp_token,omitempty"`
}

// HandleTokenRequestFormdataBody defines parameters for HandleTokenRequest.
type HandleTokenRequestFormdataBody struct {
	Assertion              *string `form:"assertion,omitempty" json:"assertion,omitempty"`
	ClientId               *string `form:"client_id,omitempty" json:"client_id,omitempty"`
	Code                   *string `form:"code,omitempty" json:"code,omitempty"`
	CodeVerifier           *string `form:"code_verifier,omitempty" json:"code_verifier,omitempty"`
	GrantType              string  `form:"grant_type" json:"grant_type"`
	PresentationSubmission *string `form:"presentation_submission,omitempty" json:"presentation_submission,omitempty"`
	Scope                  *string `form:"scope,omitempty" json:"scope,omitempty"`
}

// IntrospectAccessTokenFormdataRequestBody defines body for IntrospectAccessToken for application/x-www-form-urlencoded ContentType.
type IntrospectAccessTokenFormdataRequestBody = TokenIntrospectionRequest

// IntrospectAccessTokenExtendedFormdataRequestBody defines body for IntrospectAccessTokenExtended for application/x-www-form-urlencoded ContentType.
type IntrospectAccessTokenExtendedFormdataRequestBody = TokenIntrospectionRequest

// ValidateDPoPProofJSONRequestBody defines body for ValidateDPoPProof for application/json ContentType.
type ValidateDPoPProofJSONRequestBody = DPoPValidateRequest

// CreateDPoPProofJSONRequestBody defines body for CreateDPoPProof for application/json ContentType.
type CreateDPoPProofJSONRequestBody = DPoPRequest

// RequestOpenid4VCICredentialIssuanceJSONRequestBody defines body for RequestOpenid4VCICredentialIssuance for application/json ContentType.
type RequestOpenid4VCICredentialIssuanceJSONRequestBody RequestOpenid4VCICredentialIssuanceJSONBody

// RequestServiceAccessTokenJSONRequestBody defines body for RequestServiceAccessToken for application/json ContentType.
type RequestServiceAccessTokenJSONRequestBody = ServiceAccessTokenRequest

// RequestUserAccessTokenJSONRequestBody defines body for RequestUserAccessToken for application/json ContentType.
type RequestUserAccessTokenJSONRequestBody = UserAccessTokenRequest

// RequestJWTByPostFormdataRequestBody defines body for RequestJWTByPost for application/x-www-form-urlencoded ContentType.
type RequestJWTByPostFormdataRequestBody RequestJWTByPostFormdataBody

// HandleAuthorizeResponseFormdataRequestBody defines body for HandleAuthorizeResponse for application/x-www-form-urlencoded ContentType.
type HandleAuthorizeResponseFormdataRequestBody HandleAuthorizeResponseFormdataBody

// HandleTokenRequestFormdataRequestBody defines body for HandleTokenRequest for application/x-www-form-urlencoded ContentType.
type HandleTokenRequestFormdataRequestBody HandleTokenRequestFormdataBody

// Getter for additional properties for ExtendedTokenIntrospectionResponse. Returns the specified
// element and whether it was found
func (a ExtendedTokenIntrospectionResponse) Get(fieldName string) (value interface{}, found bool) {
	if a.AdditionalProperties != nil {
		value, found = a.AdditionalProperties[fieldName]
	}
	return
}

// Setter for additional properties for ExtendedTokenIntrospectionResponse
func (a *ExtendedTokenIntrospectionResponse) Set(fieldName string, value interface{}) {
	if a.AdditionalProperties == nil {
		a.AdditionalProperties = make(map[string]interface{})
	}
	a.AdditionalProperties[fieldName] = value
}

// Override default JSON handling for ExtendedTokenIntrospectionResponse to handle AdditionalProperties
func (a *ExtendedTokenIntrospectionResponse) UnmarshalJSON(b []byte) error {
	object := make(map[string]json.RawMessage)
	err := json.Unmarshal(b, &object)
	if err != nil {
		return err
	}

	if raw, found := object["active"]; found {
		err = json.Unmarshal(raw, &a.Active)
		if err != nil {
			return fmt.Errorf("error reading 'active': %w", err)
		}
		delete(object, "active")
	}

	if raw, found := object["aud"]; found {
		err = json.Unmarshal(raw, &a.Aud)
		if err != nil {
			return fmt.Errorf("error reading 'aud': %w", err)
		}
		delete(object, "aud")
	}

	if raw, found := object["client_id"]; found {
		err = json.Unmarshal(raw, &a.ClientId)
		if err != nil {
			return fmt.Errorf("error reading 'client_id': %w", err)
		}
		delete(object, "client_id")
	}

	if raw, found := object["cnf"]; found {
		err = json.Unmarshal(raw, &a.Cnf)
		if err != nil {
			return fmt.Errorf("error reading 'cnf': %w", err)
		}
		delete(object, "cnf")
	}

	if raw, found := object["exp"]; found {
		err = json.Unmarshal(raw, &a.Exp)
		if err != nil {
			return fmt.Errorf("error reading 'exp': %w", err)
		}
		delete(object, "exp")
	}

	if raw, found := object["iat"]; found {
		err = json.Unmarshal(raw, &a.Iat)
		if err != nil {
			return fmt.Errorf("error reading 'iat': %w", err)
		}
		delete(object, "iat")
	}

	if raw, found := object["iss"]; found {
		err = json.Unmarshal(raw, &a.Iss)
		if err != nil {
			return fmt.Errorf("error reading 'iss': %w", err)
		}
		delete(object, "iss")
	}

	if raw, found := object["presentation_definitions"]; found {
		err = json.Unmarshal(raw, &a.PresentationDefinitions)
		if err != nil {
			return fmt.Errorf("error reading 'presentation_definitions': %w", err)
		}
		delete(object, "presentation_definitions")
	}

	if raw, found := object["presentation_submissions"]; found {
		err = json.Unmarshal(raw, &a.PresentationSubmissions)
		if err != nil {
			return fmt.Errorf("error reading 'presentation_submissions': %w", err)
		}
		delete(object, "presentation_submissions")
	}

	if raw, found := object["scope"]; found {
		err = json.Unmarshal(raw, &a.Scope)
		if err != nil {
			return fmt.Errorf("error reading 'scope': %w", err)
		}
		delete(object, "scope")
	}

	if raw, found := object["vps"]; found {
		err = json.Unmarshal(raw, &a.Vps)
		if err != nil {
			return fmt.Errorf("error reading 'vps': %w", err)
		}
		delete(object, "vps")
	}

	if len(object) != 0 {
		a.AdditionalProperties = make(map[string]interface{})
		for fieldName, fieldBuf := range object {
			var fieldVal interface{}
			err := json.Unmarshal(fieldBuf, &fieldVal)
			if err != nil {
				return fmt.Errorf("error unmarshaling field %s: %w", fieldName, err)
			}
			a.AdditionalProperties[fieldName] = fieldVal
		}
	}
	return nil
}

// Override default JSON handling for ExtendedTokenIntrospectionResponse to handle AdditionalProperties
func (a ExtendedTokenIntrospectionResponse) MarshalJSON() ([]byte, error) {
	var err error
	object := make(map[string]json.RawMessage)

	object["active"], err = json.Marshal(a.Active)
	if err != nil {
		return nil, fmt.Errorf("error marshaling 'active': %w", err)
	}

	if a.Aud != nil {
		object["aud"], err = json.Marshal(a.Aud)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'aud': %w", err)
		}
	}

	if a.ClientId != nil {
		object["client_id"], err = json.Marshal(a.ClientId)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'client_id': %w", err)
		}
	}

	if a.Cnf != nil {
		object["cnf"], err = json.Marshal(a.Cnf)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'cnf': %w", err)
		}
	}

	if a.Exp != nil {
		object["exp"], err = json.Marshal(a.Exp)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'exp': %w", err)
		}
	}

	if a.Iat != nil {
		object["iat"], err = json.Marshal(a.Iat)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'iat': %w", err)
		}
	}

	if a.Iss != nil {
		object["iss"], err = json.Marshal(a.Iss)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'iss': %w", err)
		}
	}

	if a.PresentationDefinitions != nil {
		object["presentation_definitions"], err = json.Marshal(a.PresentationDefinitions)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'presentation_definitions': %w", err)
		}
	}

	if a.PresentationSubmissions != nil {
		object["presentation_submissions"], err = json.Marshal(a.PresentationSubmissions)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'presentation_submissions': %w", err)
		}
	}

	if a.Scope != nil {
		object["scope"], err = json.Marshal(a.Scope)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'scope': %w", err)
		}
	}

	if a.Vps != nil {
		object["vps"], err = json.Marshal(a.Vps)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'vps': %w", err)
		}
	}

	for fieldName, field := range a.AdditionalProperties {
		object[fieldName], err = json.Marshal(field)
		if err != nil {
			return nil, fmt.Errorf("error marshaling '%s': %w", fieldName, err)
		}
	}
	return json.Marshal(object)
}

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Get the OAuth2 Authorization Server metadata for the specified subject.
	// (GET /.well-known/oauth-authorization-server/oauth2/{subjectID})
	OAuthAuthorizationServerMetadata(ctx echo.Context, subjectID string) error
	// Get the OpenID entity configuration for the specified subject. Required for OpenID4VP.
	// (GET /.well-known/openid-configuration/oauth2/{subjectID})
	OpenIDConfiguration(ctx echo.Context, subjectID string) error
	// Introspection endpoint to retrieve information from an Access Token as described by RFC7662.
	// It returns fields derived from the credentials that were used during authentication.
	// (POST /internal/auth/v2/accesstoken/introspect)
	IntrospectAccessToken(ctx echo.Context) error
	// Introspection endpoint to retrieve information from an Access Token as described by RFC7662.
	// It returns the same information as the non-extended API call, but with the Presentation Definitions,
	// Presentation Submissions and Verifiable Presentations added.
	// (POST /internal/auth/v2/accesstoken/introspect_extended)
	IntrospectAccessTokenExtended(ctx echo.Context) error
	// Get the access token from the Nuts node that was requested through /request-user-access-token.
	// (GET /internal/auth/v2/accesstoken/{sessionID})
	RetrieveAccessToken(ctx echo.Context, sessionID string) error
	// Handle some of the validation of a DPoP proof as specified by RFC9449.
	// (POST /internal/auth/v2/dpop/validate)
	ValidateDPoPProof(ctx echo.Context) error
	// Create a DPoP proof as specified by RFC9449 for a given access token. It is to be used as HTTP header when accessing resources.
	// (POST /internal/auth/v2/dpop/{kid})
	CreateDPoPProof(ctx echo.Context, kid string) error
	// EXPERIMENTAL Start the Oid4VCI authorization flow.
	// (POST /internal/auth/v2/{subjectID}/request-credential)
	RequestOpenid4VCICredentialIssuance(ctx echo.Context, subjectID string) error
	// Start the authorization flow to get an access token from a remote authorization server.
	// (POST /internal/auth/v2/{subjectID}/request-service-access-token)
	RequestServiceAccessToken(ctx echo.Context, subjectID string, params RequestServiceAccessTokenParams) error
	// EXPERIMENTAL Start the authorization code flow to get an access token from a remote authorization server when user context is required.
	// (POST /internal/auth/v2/{subjectID}/request-user-access-token)
	RequestUserAccessToken(ctx echo.Context, subjectID string) error
	// Used by resource owners (the browser) to initiate the authorization code flow.
	// (GET /oauth2/{subjectID}/authorize)
	HandleAuthorizeRequest(ctx echo.Context, subjectID string, params HandleAuthorizeRequestParams) error
	// The OAuth2 callback endpoint of the client.
	// (GET /oauth2/{subjectID}/callback)
	Callback(ctx echo.Context, subjectID string, params CallbackParams) error
	// Get the OAuth2 Client metadata
	// (GET /oauth2/{subjectID}/oauth-client)
	OAuthClientMetadata(ctx echo.Context, subjectID string) error
	// Used by relying parties to obtain a presentation definition for desired scopes as specified by Nuts RFC021.
	// (GET /oauth2/{subjectID}/presentation_definition)
	PresentationDefinition(ctx echo.Context, subjectID string, params PresentationDefinitionParams) error
	// Get Request Object referenced in an authorization request to the Authorization Server.
	// (GET /oauth2/{subjectID}/request.jwt/{id})
	RequestJWTByGet(ctx echo.Context, subjectID string, id string) error
	// Provide missing information to Client to finish Authorization request's Request Object, which is then returned.
	// (POST /oauth2/{subjectID}/request.jwt/{id})
	RequestJWTByPost(ctx echo.Context, subjectID string, id string) error
	// Used by wallets to post the authorization response or error to.
	// (POST /oauth2/{subjectID}/response)
	HandleAuthorizeResponse(ctx echo.Context, subjectID string) error
	// Used by the OAuth2 client (backend, not the browser) to request access- or refresh tokens.
	// (POST /oauth2/{subjectID}/token)
	HandleTokenRequest(ctx echo.Context, subjectID string) error
	// Get the StatusList2021Credential for the given DID and page
	// (GET /statuslist/{did}/{page})
	StatusList(ctx echo.Context, did string, page int) error
}

// ServerInterfaceWrapper converts echo contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler ServerInterface
}

// OAuthAuthorizationServerMetadata converts echo context to params.
func (w *ServerInterfaceWrapper) OAuthAuthorizationServerMetadata(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.OAuthAuthorizationServerMetadata(ctx, subjectID)
	return err
}

// OpenIDConfiguration converts echo context to params.
func (w *ServerInterfaceWrapper) OpenIDConfiguration(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.OpenIDConfiguration(ctx, subjectID)
	return err
}

// IntrospectAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) IntrospectAccessToken(ctx echo.Context) error {
	var err error

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.IntrospectAccessToken(ctx)
	return err
}

// IntrospectAccessTokenExtended converts echo context to params.
func (w *ServerInterfaceWrapper) IntrospectAccessTokenExtended(ctx echo.Context) error {
	var err error

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.IntrospectAccessTokenExtended(ctx)
	return err
}

// RetrieveAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) RetrieveAccessToken(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "sessionID" -------------
	var sessionID string

	err = runtime.BindStyledParameterWithOptions("simple", "sessionID", ctx.Param("sessionID"), &sessionID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sessionID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RetrieveAccessToken(ctx, sessionID)
	return err
}

// ValidateDPoPProof converts echo context to params.
func (w *ServerInterfaceWrapper) ValidateDPoPProof(ctx echo.Context) error {
	var err error

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.ValidateDPoPProof(ctx)
	return err
}

// CreateDPoPProof converts echo context to params.
func (w *ServerInterfaceWrapper) CreateDPoPProof(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "kid" -------------
	var kid string

	kid = ctx.Param("kid")

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.CreateDPoPProof(ctx, kid)
	return err
}

// RequestOpenid4VCICredentialIssuance converts echo context to params.
func (w *ServerInterfaceWrapper) RequestOpenid4VCICredentialIssuance(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RequestOpenid4VCICredentialIssuance(ctx, subjectID)
	return err
}

// RequestServiceAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) RequestServiceAccessToken(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Parameter object where we will unmarshal all parameters from the context
	var params RequestServiceAccessTokenParams

	headers := ctx.Request().Header
	// ------------- Optional header parameter "Cache-Control" -------------
	if valueList, found := headers[http.CanonicalHeaderKey("Cache-Control")]; found {
		var CacheControl string
		n := len(valueList)
		if n != 1 {
			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Expected one value for Cache-Control, got %d", n))
		}

		err = runtime.BindStyledParameterWithOptions("simple", "Cache-Control", valueList[0], &CacheControl, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationHeader, Explode: false, Required: false})
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter Cache-Control: %s", err))
		}

		params.CacheControl = &CacheControl
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RequestServiceAccessToken(ctx, subjectID, params)
	return err
}

// RequestUserAccessToken converts echo context to params.
func (w *ServerInterfaceWrapper) RequestUserAccessToken(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RequestUserAccessToken(ctx, subjectID)
	return err
}

// HandleAuthorizeRequest converts echo context to params.
func (w *ServerInterfaceWrapper) HandleAuthorizeRequest(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Parameter object where we will unmarshal all parameters from the context
	var params HandleAuthorizeRequestParams
	// ------------- Optional query parameter "params" -------------

	err = runtime.BindQueryParameter("form", true, false, "params", ctx.QueryParams(), &params.Params)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter params: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.HandleAuthorizeRequest(ctx, subjectID, params)
	return err
}

// Callback converts echo context to params.
func (w *ServerInterfaceWrapper) Callback(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Parameter object where we will unmarshal all parameters from the context
	var params CallbackParams
	// ------------- Optional query parameter "code" -------------

	err = runtime.BindQueryParameter("form", true, false, "code", ctx.QueryParams(), &params.Code)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter code: %s", err))
	}

	// ------------- Optional query parameter "state" -------------

	err = runtime.BindQueryParameter("form", true, false, "state", ctx.QueryParams(), &params.State)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter state: %s", err))
	}

	// ------------- Optional query parameter "error" -------------

	err = runtime.BindQueryParameter("form", true, false, "error", ctx.QueryParams(), &params.Error)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter error: %s", err))
	}

	// ------------- Optional query parameter "error_description" -------------

	err = runtime.BindQueryParameter("form", true, false, "error_description", ctx.QueryParams(), &params.ErrorDescription)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter error_description: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.Callback(ctx, subjectID, params)
	return err
}

// OAuthClientMetadata converts echo context to params.
func (w *ServerInterfaceWrapper) OAuthClientMetadata(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.OAuthClientMetadata(ctx, subjectID)
	return err
}

// PresentationDefinition converts echo context to params.
func (w *ServerInterfaceWrapper) PresentationDefinition(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Parameter object where we will unmarshal all parameters from the context
	var params PresentationDefinitionParams
	// ------------- Required query parameter "scope" -------------

	err = runtime.BindQueryParameter("form", true, true, "scope", ctx.QueryParams(), &params.Scope)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter scope: %s", err))
	}

	// ------------- Optional query parameter "wallet_owner_type" -------------

	err = runtime.BindQueryParameter("form", true, false, "wallet_owner_type", ctx.QueryParams(), &params.WalletOwnerType)
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter wallet_owner_type: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PresentationDefinition(ctx, subjectID, params)
	return err
}

// RequestJWTByGet converts echo context to params.
func (w *ServerInterfaceWrapper) RequestJWTByGet(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	// ------------- Path parameter "id" -------------
	var id string

	err = runtime.BindStyledParameterWithOptions("simple", "id", ctx.Param("id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter id: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RequestJWTByGet(ctx, subjectID, id)
	return err
}

// RequestJWTByPost converts echo context to params.
func (w *ServerInterfaceWrapper) RequestJWTByPost(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	// ------------- Path parameter "id" -------------
	var id string

	err = runtime.BindStyledParameterWithOptions("simple", "id", ctx.Param("id"), &id, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter id: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.RequestJWTByPost(ctx, subjectID, id)
	return err
}

// HandleAuthorizeResponse converts echo context to params.
func (w *ServerInterfaceWrapper) HandleAuthorizeResponse(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	subjectID = ctx.Param("subjectID")

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.HandleAuthorizeResponse(ctx, subjectID)
	return err
}

// HandleTokenRequest converts echo context to params.
func (w *ServerInterfaceWrapper) HandleTokenRequest(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "subjectID" -------------
	var subjectID string

	err = runtime.BindStyledParameterWithOptions("simple", "subjectID", ctx.Param("subjectID"), &subjectID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subjectID: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.HandleTokenRequest(ctx, subjectID)
	return err
}

// StatusList converts echo context to params.
func (w *ServerInterfaceWrapper) StatusList(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "did" -------------
	var did string

	did = ctx.Param("did")

	// ------------- Path parameter "page" -------------
	var page int

	err = runtime.BindStyledParameterWithOptions("simple", "page", ctx.Param("page"), &page, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter page: %s", err))
	}

	ctx.Set(JwtBearerAuthScopes, []string{})

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.StatusList(ctx, did, page)
	return err
}

// This is a simple interface which specifies echo.Route addition functions which
// are present on both echo.Echo and echo.Group, since we want to allow using
// either of them for path registration
type EchoRouter interface {
	CONNECT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	DELETE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	GET(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	HEAD(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	OPTIONS(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PATCH(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	POST(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	PUT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
	TRACE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
}

// RegisterHandlers adds each server route to the EchoRouter.
func RegisterHandlers(router EchoRouter, si ServerInterface) {
	RegisterHandlersWithBaseURL(router, si, "")
}

// Registers handlers, and prepends BaseURL to the paths, so that the paths
// can be served under a prefix.
func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string) {

	wrapper := ServerInterfaceWrapper{
		Handler: si,
	}

	router.GET(baseURL+"/.well-known/oauth-authorization-server/oauth2/:subjectID", wrapper.OAuthAuthorizationServerMetadata)
	router.GET(baseURL+"/.well-known/openid-configuration/oauth2/:subjectID", wrapper.OpenIDConfiguration)
	router.POST(baseURL+"/internal/auth/v2/accesstoken/introspect", wrapper.IntrospectAccessToken)
	router.POST(baseURL+"/internal/auth/v2/accesstoken/introspect_extended", wrapper.IntrospectAccessTokenExtended)
	router.GET(baseURL+"/internal/auth/v2/accesstoken/:sessionID", wrapper.RetrieveAccessToken)
	router.POST(baseURL+"/internal/auth/v2/dpop/validate", wrapper.ValidateDPoPProof)
	router.POST(baseURL+"/internal/auth/v2/dpop/:kid", wrapper.CreateDPoPProof)
	router.POST(baseURL+"/internal/auth/v2/:subjectID/request-credential", wrapper.RequestOpenid4VCICredentialIssuance)
	router.POST(baseURL+"/internal/auth/v2/:subjectID/request-service-access-token", wrapper.RequestServiceAccessToken)
	router.POST(baseURL+"/internal/auth/v2/:subjectID/request-user-access-token", wrapper.RequestUserAccessToken)
	router.GET(baseURL+"/oauth2/:subjectID/authorize", wrapper.HandleAuthorizeRequest)
	router.GET(baseURL+"/oauth2/:subjectID/callback", wrapper.Callback)
	router.GET(baseURL+"/oauth2/:subjectID/oauth-client", wrapper.OAuthClientMetadata)
	router.GET(baseURL+"/oauth2/:subjectID/presentation_definition", wrapper.PresentationDefinition)
	router.GET(baseURL+"/oauth2/:subjectID/request.jwt/:id", wrapper.RequestJWTByGet)
	router.POST(baseURL+"/oauth2/:subjectID/request.jwt/:id", wrapper.RequestJWTByPost)
	router.POST(baseURL+"/oauth2/:subjectID/response", wrapper.HandleAuthorizeResponse)
	router.POST(baseURL+"/oauth2/:subjectID/token", wrapper.HandleTokenRequest)
	router.GET(baseURL+"/statuslist/:did/:page", wrapper.StatusList)

}

type OAuthAuthorizationServerMetadataRequestObject struct {
	SubjectID string `json:"subjectID"`
}

type OAuthAuthorizationServerMetadataResponseObject interface {
	VisitOAuthAuthorizationServerMetadataResponse(w http.ResponseWriter) error
}

type OAuthAuthorizationServerMetadata200JSONResponse OAuthAuthorizationServerMetadata

func (response OAuthAuthorizationServerMetadata200JSONResponse) VisitOAuthAuthorizationServerMetadataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type OAuthAuthorizationServerMetadatadefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response OAuthAuthorizationServerMetadatadefaultApplicationProblemPlusJSONResponse) VisitOAuthAuthorizationServerMetadataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type OpenIDConfigurationRequestObject struct {
	SubjectID string `json:"subjectID"`
}

type OpenIDConfigurationResponseObject interface {
	VisitOpenIDConfigurationResponse(w http.ResponseWriter) error
}

type OpenIDConfiguration200ApplicationentityStatementJwtResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response OpenIDConfiguration200ApplicationentityStatementJwtResponse) VisitOpenIDConfigurationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/entity-statement+jwt")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type OpenIDConfigurationdefaultJSONResponse struct {
	Body       ErrorResponse
	StatusCode int
}

func (response OpenIDConfigurationdefaultJSONResponse) VisitOpenIDConfigurationResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type IntrospectAccessTokenRequestObject struct {
	Body *IntrospectAccessTokenFormdataRequestBody
}

type IntrospectAccessTokenResponseObject interface {
	VisitIntrospectAccessTokenResponse(w http.ResponseWriter) error
}

type IntrospectAccessToken200JSONResponse TokenIntrospectionResponse

func (response IntrospectAccessToken200JSONResponse) VisitIntrospectAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type IntrospectAccessToken401Response struct {
}

func (response IntrospectAccessToken401Response) VisitIntrospectAccessTokenResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type IntrospectAccessTokenExtendedRequestObject struct {
	Body *IntrospectAccessTokenExtendedFormdataRequestBody
}

type IntrospectAccessTokenExtendedResponseObject interface {
	VisitIntrospectAccessTokenExtendedResponse(w http.ResponseWriter) error
}

type IntrospectAccessTokenExtended200JSONResponse ExtendedTokenIntrospectionResponse

func (response IntrospectAccessTokenExtended200JSONResponse) VisitIntrospectAccessTokenExtendedResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type IntrospectAccessTokenExtended401Response struct {
}

func (response IntrospectAccessTokenExtended401Response) VisitIntrospectAccessTokenExtendedResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type RetrieveAccessTokenRequestObject struct {
	SessionID string `json:"sessionID"`
}

type RetrieveAccessTokenResponseObject interface {
	VisitRetrieveAccessTokenResponse(w http.ResponseWriter) error
}

type RetrieveAccessToken200JSONResponse TokenResponse

func (response RetrieveAccessToken200JSONResponse) VisitRetrieveAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type RetrieveAccessTokendefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RetrieveAccessTokendefaultApplicationProblemPlusJSONResponse) VisitRetrieveAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type ValidateDPoPProofRequestObject struct {
	Body *ValidateDPoPProofJSONRequestBody
}

type ValidateDPoPProofResponseObject interface {
	VisitValidateDPoPProofResponse(w http.ResponseWriter) error
}

type ValidateDPoPProof200JSONResponse DPoPValidateResponse

func (response ValidateDPoPProof200JSONResponse) VisitValidateDPoPProofResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type ValidateDPoPProofdefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response ValidateDPoPProofdefaultApplicationProblemPlusJSONResponse) VisitValidateDPoPProofResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type CreateDPoPProofRequestObject struct {
	Kid  string `json:"kid"`
	Body *CreateDPoPProofJSONRequestBody
}

type CreateDPoPProofResponseObject interface {
	VisitCreateDPoPProofResponse(w http.ResponseWriter) error
}

type CreateDPoPProof200JSONResponse DPoPResponse

func (response CreateDPoPProof200JSONResponse) VisitCreateDPoPProofResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type CreateDPoPProof401Response struct {
}

func (response CreateDPoPProof401Response) VisitCreateDPoPProofResponse(w http.ResponseWriter) error {
	w.WriteHeader(401)
	return nil
}

type RequestOpenid4VCICredentialIssuanceRequestObject struct {
	SubjectID string `json:"subjectID"`
	Body      *RequestOpenid4VCICredentialIssuanceJSONRequestBody
}

type RequestOpenid4VCICredentialIssuanceResponseObject interface {
	VisitRequestOpenid4VCICredentialIssuanceResponse(w http.ResponseWriter) error
}

type RequestOpenid4VCICredentialIssuance200JSONResponse RedirectResponse

func (response RequestOpenid4VCICredentialIssuance200JSONResponse) VisitRequestOpenid4VCICredentialIssuanceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type RequestOpenid4VCICredentialIssuancedefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RequestOpenid4VCICredentialIssuancedefaultApplicationProblemPlusJSONResponse) VisitRequestOpenid4VCICredentialIssuanceResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type RequestServiceAccessTokenRequestObject struct {
	SubjectID string `json:"subjectID"`
	Params    RequestServiceAccessTokenParams
	Body      *RequestServiceAccessTokenJSONRequestBody
}

type RequestServiceAccessTokenResponseObject interface {
	VisitRequestServiceAccessTokenResponse(w http.ResponseWriter) error
}

type RequestServiceAccessToken200JSONResponse TokenResponse

func (response RequestServiceAccessToken200JSONResponse) VisitRequestServiceAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type RequestServiceAccessTokendefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RequestServiceAccessTokendefaultApplicationProblemPlusJSONResponse) VisitRequestServiceAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type RequestUserAccessTokenRequestObject struct {
	SubjectID string `json:"subjectID"`
	Body      *RequestUserAccessTokenJSONRequestBody
}

type RequestUserAccessTokenResponseObject interface {
	VisitRequestUserAccessTokenResponse(w http.ResponseWriter) error
}

type RequestUserAccessToken200JSONResponse RedirectResponseWithID

func (response RequestUserAccessToken200JSONResponse) VisitRequestUserAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type RequestUserAccessTokendefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RequestUserAccessTokendefaultApplicationProblemPlusJSONResponse) VisitRequestUserAccessTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type HandleAuthorizeRequestRequestObject struct {
	SubjectID string `json:"subjectID"`
	Params    HandleAuthorizeRequestParams
}

type HandleAuthorizeRequestResponseObject interface {
	VisitHandleAuthorizeRequestResponse(w http.ResponseWriter) error
}

type HandleAuthorizeRequest200TexthtmlResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response HandleAuthorizeRequest200TexthtmlResponse) VisitHandleAuthorizeRequestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "text/html")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type HandleAuthorizeRequest302ResponseHeaders struct {
	Location string
}

type HandleAuthorizeRequest302Response struct {
	Headers HandleAuthorizeRequest302ResponseHeaders
}

func (response HandleAuthorizeRequest302Response) VisitHandleAuthorizeRequestResponse(w http.ResponseWriter) error {
	w.Header().Set("Location", fmt.Sprint(response.Headers.Location))
	w.WriteHeader(302)
	return nil
}

type CallbackRequestObject struct {
	SubjectID string `json:"subjectID"`
	Params    CallbackParams
}

type CallbackResponseObject interface {
	VisitCallbackResponse(w http.ResponseWriter) error
}

type Callback302ResponseHeaders struct {
	Location string
}

type Callback302Response struct {
	Headers Callback302ResponseHeaders
}

func (response Callback302Response) VisitCallbackResponse(w http.ResponseWriter) error {
	w.Header().Set("Location", fmt.Sprint(response.Headers.Location))
	w.WriteHeader(302)
	return nil
}

type CallbackdefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response CallbackdefaultApplicationProblemPlusJSONResponse) VisitCallbackResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type OAuthClientMetadataRequestObject struct {
	SubjectID string `json:"subjectID"`
}

type OAuthClientMetadataResponseObject interface {
	VisitOAuthClientMetadataResponse(w http.ResponseWriter) error
}

type OAuthClientMetadata200JSONResponse OAuthClientMetadata

func (response OAuthClientMetadata200JSONResponse) VisitOAuthClientMetadataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type OAuthClientMetadatadefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response OAuthClientMetadatadefaultApplicationProblemPlusJSONResponse) VisitOAuthClientMetadataResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type PresentationDefinitionRequestObject struct {
	SubjectID string `json:"subjectID"`
	Params    PresentationDefinitionParams
}

type PresentationDefinitionResponseObject interface {
	VisitPresentationDefinitionResponse(w http.ResponseWriter) error
}

type PresentationDefinition200JSONResponse PresentationDefinition

func (response PresentationDefinition200JSONResponse) VisitPresentationDefinitionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type PresentationDefinitiondefaultJSONResponse struct {
	Body       ErrorResponse
	StatusCode int
}

func (response PresentationDefinitiondefaultJSONResponse) VisitPresentationDefinitionResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type RequestJWTByGetRequestObject struct {
	SubjectID string `json:"subjectID"`
	Id        string `json:"id"`
}

type RequestJWTByGetResponseObject interface {
	VisitRequestJWTByGetResponse(w http.ResponseWriter) error
}

type RequestJWTByGet200ApplicationoauthAuthzReqJwtResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response RequestJWTByGet200ApplicationoauthAuthzReqJwtResponse) VisitRequestJWTByGetResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/oauth-authz-req+jwt")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type RequestJWTByGetdefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RequestJWTByGetdefaultApplicationProblemPlusJSONResponse) VisitRequestJWTByGetResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type RequestJWTByPostRequestObject struct {
	SubjectID string `json:"subjectID"`
	Id        string `json:"id"`
	Body      *RequestJWTByPostFormdataRequestBody
}

type RequestJWTByPostResponseObject interface {
	VisitRequestJWTByPostResponse(w http.ResponseWriter) error
}

type RequestJWTByPost200ApplicationoauthAuthzReqJwtResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response RequestJWTByPost200ApplicationoauthAuthzReqJwtResponse) VisitRequestJWTByPostResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/oauth-authz-req+jwt")
	if response.ContentLength != 0 {
		w.Header().Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	w.WriteHeader(200)

	if closer, ok := response.Body.(io.ReadCloser); ok {
		defer closer.Close()
	}
	_, err := io.Copy(w, response.Body)
	return err
}

type RequestJWTByPostdefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response RequestJWTByPostdefaultApplicationProblemPlusJSONResponse) VisitRequestJWTByPostResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type HandleAuthorizeResponseRequestObject struct {
	SubjectID string `json:"subjectID"`
	Body      *HandleAuthorizeResponseFormdataRequestBody
}

type HandleAuthorizeResponseResponseObject interface {
	VisitHandleAuthorizeResponseResponse(w http.ResponseWriter) error
}

type HandleAuthorizeResponse200JSONResponse RedirectResponse

func (response HandleAuthorizeResponse200JSONResponse) VisitHandleAuthorizeResponseResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type HandleTokenRequestRequestObject struct {
	SubjectID string `json:"subjectID"`
	Body      *HandleTokenRequestFormdataRequestBody
}

type HandleTokenRequestResponseObject interface {
	VisitHandleTokenRequestResponse(w http.ResponseWriter) error
}

type HandleTokenRequest200JSONResponse TokenResponse

func (response HandleTokenRequest200JSONResponse) VisitHandleTokenRequestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type HandleTokenRequestdefaultJSONResponse struct {
	Body       ErrorResponse
	StatusCode int
}

func (response HandleTokenRequestdefaultJSONResponse) VisitHandleTokenRequestResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

type StatusListRequestObject struct {
	Did  string `json:"did"`
	Page int    `json:"page"`
}

type StatusListResponseObject interface {
	VisitStatusListResponse(w http.ResponseWriter) error
}

type StatusList200JSONResponse VerifiableCredential

func (response StatusList200JSONResponse) VisitStatusListResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type StatusListdefaultApplicationProblemPlusJSONResponse struct {
	Body struct {
		// Detail A human-readable explanation specific to this occurrence of the problem.
		Detail string `json:"detail"`

		// Status HTTP statuscode
		Status float32 `json:"status"`

		// Title A short, human-readable summary of the problem type.
		Title string `json:"title"`
	}
	StatusCode int
}

func (response StatusListdefaultApplicationProblemPlusJSONResponse) VisitStatusListResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(response.StatusCode)

	return json.NewEncoder(w).Encode(response.Body)
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// Get the OAuth2 Authorization Server metadata for the specified subject.
	// (GET /.well-known/oauth-authorization-server/oauth2/{subjectID})
	OAuthAuthorizationServerMetadata(ctx context.Context, request OAuthAuthorizationServerMetadataRequestObject) (OAuthAuthorizationServerMetadataResponseObject, error)
	// Get the OpenID entity configuration for the specified subject. Required for OpenID4VP.
	// (GET /.well-known/openid-configuration/oauth2/{subjectID})
	OpenIDConfiguration(ctx context.Context, request OpenIDConfigurationRequestObject) (OpenIDConfigurationResponseObject, error)
	// Introspection endpoint to retrieve information from an Access Token as described by RFC7662.
	// It returns fields derived from the credentials that were used during authentication.
	// (POST /internal/auth/v2/accesstoken/introspect)
	IntrospectAccessToken(ctx context.Context, request IntrospectAccessTokenRequestObject) (IntrospectAccessTokenResponseObject, error)
	// Introspection endpoint to retrieve information from an Access Token as described by RFC7662.
	// It returns the same information as the non-extended API call, but with the Presentation Definitions,
	// Presentation Submissions and Verifiable Presentations added.
	// (POST /internal/auth/v2/accesstoken/introspect_extended)
	IntrospectAccessTokenExtended(ctx context.Context, request IntrospectAccessTokenExtendedRequestObject) (IntrospectAccessTokenExtendedResponseObject, error)
	// Get the access token from the Nuts node that was requested through /request-user-access-token.
	// (GET /internal/auth/v2/accesstoken/{sessionID})
	RetrieveAccessToken(ctx context.Context, request RetrieveAccessTokenRequestObject) (RetrieveAccessTokenResponseObject, error)
	// Handle some of the validation of a DPoP proof as specified by RFC9449.
	// (POST /internal/auth/v2/dpop/validate)
	ValidateDPoPProof(ctx context.Context, request ValidateDPoPProofRequestObject) (ValidateDPoPProofResponseObject, error)
	// Create a DPoP proof as specified by RFC9449 for a given access token. It is to be used as HTTP header when accessing resources.
	// (POST /internal/auth/v2/dpop/{kid})
	CreateDPoPProof(ctx context.Context, request CreateDPoPProofRequestObject) (CreateDPoPProofResponseObject, error)
	// EXPERIMENTAL Start the Oid4VCI authorization flow.
	// (POST /internal/auth/v2/{subjectID}/request-credential)
	RequestOpenid4VCICredentialIssuance(ctx context.Context, request RequestOpenid4VCICredentialIssuanceRequestObject) (RequestOpenid4VCICredentialIssuanceResponseObject, error)
	// Start the authorization flow to get an access token from a remote authorization server.
	// (POST /internal/auth/v2/{subjectID}/request-service-access-token)
	RequestServiceAccessToken(ctx context.Context, request RequestServiceAccessTokenRequestObject) (RequestServiceAccessTokenResponseObject, error)
	// EXPERIMENTAL Start the authorization code flow to get an access token from a remote authorization server when user context is required.
	// (POST /internal/auth/v2/{subjectID}/request-user-access-token)
	RequestUserAccessToken(ctx context.Context, request RequestUserAccessTokenRequestObject) (RequestUserAccessTokenResponseObject, error)
	// Used by resource owners (the browser) to initiate the authorization code flow.
	// (GET /oauth2/{subjectID}/authorize)
	HandleAuthorizeRequest(ctx context.Context, request HandleAuthorizeRequestRequestObject) (HandleAuthorizeRequestResponseObject, error)
	// The OAuth2 callback endpoint of the client.
	// (GET /oauth2/{subjectID}/callback)
	Callback(ctx context.Context, request CallbackRequestObject) (CallbackResponseObject, error)
	// Get the OAuth2 Client metadata
	// (GET /oauth2/{subjectID}/oauth-client)
	OAuthClientMetadata(ctx context.Context, request OAuthClientMetadataRequestObject) (OAuthClientMetadataResponseObject, error)
	// Used by relying parties to obtain a presentation definition for desired scopes as specified by Nuts RFC021.
	// (GET /oauth2/{subjectID}/presentation_definition)
	PresentationDefinition(ctx context.Context, request PresentationDefinitionRequestObject) (PresentationDefinitionResponseObject, error)
	// Get Request Object referenced in an authorization request to the Authorization Server.
	// (GET /oauth2/{subjectID}/request.jwt/{id})
	RequestJWTByGet(ctx context.Context, request RequestJWTByGetRequestObject) (RequestJWTByGetResponseObject, error)
	// Provide missing information to Client to finish Authorization request's Request Object, which is then returned.
	// (POST /oauth2/{subjectID}/request.jwt/{id})
	RequestJWTByPost(ctx context.Context, request RequestJWTByPostRequestObject) (RequestJWTByPostResponseObject, error)
	// Used by wallets to post the authorization response or error to.
	// (POST /oauth2/{subjectID}/response)
	HandleAuthorizeResponse(ctx context.Context, request HandleAuthorizeResponseRequestObject) (HandleAuthorizeResponseResponseObject, error)
	// Used by the OAuth2 client (backend, not the browser) to request access- or refresh tokens.
	// (POST /oauth2/{subjectID}/token)
	HandleTokenRequest(ctx context.Context, request HandleTokenRequestRequestObject) (HandleTokenRequestResponseObject, error)
	// Get the StatusList2021Credential for the given DID and page
	// (GET /statuslist/{did}/{page})
	StatusList(ctx context.Context, request StatusListRequestObject) (StatusListResponseObject, error)
}

type StrictHandlerFunc = strictecho.StrictEchoHandlerFunc
type StrictMiddlewareFunc = strictecho.StrictEchoMiddlewareFunc

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
}

// OAuthAuthorizationServerMetadata operation middleware
func (sh *strictHandler) OAuthAuthorizationServerMetadata(ctx echo.Context, subjectID string) error {
	var request OAuthAuthorizationServerMetadataRequestObject

	request.SubjectID = subjectID

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.OAuthAuthorizationServerMetadata(ctx.Request().Context(), request.(OAuthAuthorizationServerMetadataRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "OAuthAuthorizationServerMetadata")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(OAuthAuthorizationServerMetadataResponseObject); ok {
		return validResponse.VisitOAuthAuthorizationServerMetadataResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// OpenIDConfiguration operation middleware
func (sh *strictHandler) OpenIDConfiguration(ctx echo.Context, subjectID string) error {
	var request OpenIDConfigurationRequestObject

	request.SubjectID = subjectID

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.OpenIDConfiguration(ctx.Request().Context(), request.(OpenIDConfigurationRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "OpenIDConfiguration")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(OpenIDConfigurationResponseObject); ok {
		return validResponse.VisitOpenIDConfigurationResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// IntrospectAccessToken operation middleware
func (sh *strictHandler) IntrospectAccessToken(ctx echo.Context) error {
	var request IntrospectAccessTokenRequestObject

	if form, err := ctx.FormParams(); err == nil {
		var body IntrospectAccessTokenFormdataRequestBody
		if err := runtime.BindForm(&body, form, nil, nil); err != nil {
			return err
		}
		request.Body = &body
	} else {
		return err
	}

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.IntrospectAccessToken(ctx.Request().Context(), request.(IntrospectAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "IntrospectAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(IntrospectAccessTokenResponseObject); ok {
		return validResponse.VisitIntrospectAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// IntrospectAccessTokenExtended operation middleware
func (sh *strictHandler) IntrospectAccessTokenExtended(ctx echo.Context) error {
	var request IntrospectAccessTokenExtendedRequestObject

	if form, err := ctx.FormParams(); err == nil {
		var body IntrospectAccessTokenExtendedFormdataRequestBody
		if err := runtime.BindForm(&body, form, nil, nil); err != nil {
			return err
		}
		request.Body = &body
	} else {
		return err
	}

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.IntrospectAccessTokenExtended(ctx.Request().Context(), request.(IntrospectAccessTokenExtendedRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "IntrospectAccessTokenExtended")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(IntrospectAccessTokenExtendedResponseObject); ok {
		return validResponse.VisitIntrospectAccessTokenExtendedResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RetrieveAccessToken operation middleware
func (sh *strictHandler) RetrieveAccessToken(ctx echo.Context, sessionID string) error {
	var request RetrieveAccessTokenRequestObject

	request.SessionID = sessionID

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RetrieveAccessToken(ctx.Request().Context(), request.(RetrieveAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RetrieveAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RetrieveAccessTokenResponseObject); ok {
		return validResponse.VisitRetrieveAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ValidateDPoPProof operation middleware
func (sh *strictHandler) ValidateDPoPProof(ctx echo.Context) error {
	var request ValidateDPoPProofRequestObject

	var body ValidateDPoPProofJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.ValidateDPoPProof(ctx.Request().Context(), request.(ValidateDPoPProofRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ValidateDPoPProof")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(ValidateDPoPProofResponseObject); ok {
		return validResponse.VisitValidateDPoPProofResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateDPoPProof operation middleware
func (sh *strictHandler) CreateDPoPProof(ctx echo.Context, kid string) error {
	var request CreateDPoPProofRequestObject

	request.Kid = kid

	var body CreateDPoPProofJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.CreateDPoPProof(ctx.Request().Context(), request.(CreateDPoPProofRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateDPoPProof")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CreateDPoPProofResponseObject); ok {
		return validResponse.VisitCreateDPoPProofResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RequestOpenid4VCICredentialIssuance operation middleware
func (sh *strictHandler) RequestOpenid4VCICredentialIssuance(ctx echo.Context, subjectID string) error {
	var request RequestOpenid4VCICredentialIssuanceRequestObject

	request.SubjectID = subjectID

	var body RequestOpenid4VCICredentialIssuanceJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RequestOpenid4VCICredentialIssuance(ctx.Request().Context(), request.(RequestOpenid4VCICredentialIssuanceRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RequestOpenid4VCICredentialIssuance")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RequestOpenid4VCICredentialIssuanceResponseObject); ok {
		return validResponse.VisitRequestOpenid4VCICredentialIssuanceResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RequestServiceAccessToken operation middleware
func (sh *strictHandler) RequestServiceAccessToken(ctx echo.Context, subjectID string, params RequestServiceAccessTokenParams) error {
	var request RequestServiceAccessTokenRequestObject

	request.SubjectID = subjectID
	request.Params = params

	var body RequestServiceAccessTokenJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RequestServiceAccessToken(ctx.Request().Context(), request.(RequestServiceAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RequestServiceAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RequestServiceAccessTokenResponseObject); ok {
		return validResponse.VisitRequestServiceAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RequestUserAccessToken operation middleware
func (sh *strictHandler) RequestUserAccessToken(ctx echo.Context, subjectID string) error {
	var request RequestUserAccessTokenRequestObject

	request.SubjectID = subjectID

	var body RequestUserAccessTokenJSONRequestBody
	if err := ctx.Bind(&body); err != nil {
		return err
	}
	request.Body = &body

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RequestUserAccessToken(ctx.Request().Context(), request.(RequestUserAccessTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RequestUserAccessToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RequestUserAccessTokenResponseObject); ok {
		return validResponse.VisitRequestUserAccessTokenResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// HandleAuthorizeRequest operation middleware
func (sh *strictHandler) HandleAuthorizeRequest(ctx echo.Context, subjectID string, params HandleAuthorizeRequestParams) error {
	var request HandleAuthorizeRequestRequestObject

	request.SubjectID = subjectID
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.HandleAuthorizeRequest(ctx.Request().Context(), request.(HandleAuthorizeRequestRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "HandleAuthorizeRequest")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(HandleAuthorizeRequestResponseObject); ok {
		return validResponse.VisitHandleAuthorizeRequestResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// Callback operation middleware
func (sh *strictHandler) Callback(ctx echo.Context, subjectID string, params CallbackParams) error {
	var request CallbackRequestObject

	request.SubjectID = subjectID
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.Callback(ctx.Request().Context(), request.(CallbackRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "Callback")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(CallbackResponseObject); ok {
		return validResponse.VisitCallbackResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// OAuthClientMetadata operation middleware
func (sh *strictHandler) OAuthClientMetadata(ctx echo.Context, subjectID string) error {
	var request OAuthClientMetadataRequestObject

	request.SubjectID = subjectID

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.OAuthClientMetadata(ctx.Request().Context(), request.(OAuthClientMetadataRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "OAuthClientMetadata")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(OAuthClientMetadataResponseObject); ok {
		return validResponse.VisitOAuthClientMetadataResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// PresentationDefinition operation middleware
func (sh *strictHandler) PresentationDefinition(ctx echo.Context, subjectID string, params PresentationDefinitionParams) error {
	var request PresentationDefinitionRequestObject

	request.SubjectID = subjectID
	request.Params = params

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.PresentationDefinition(ctx.Request().Context(), request.(PresentationDefinitionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "PresentationDefinition")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(PresentationDefinitionResponseObject); ok {
		return validResponse.VisitPresentationDefinitionResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RequestJWTByGet operation middleware
func (sh *strictHandler) RequestJWTByGet(ctx echo.Context, subjectID string, id string) error {
	var request RequestJWTByGetRequestObject

	request.SubjectID = subjectID
	request.Id = id

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RequestJWTByGet(ctx.Request().Context(), request.(RequestJWTByGetRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RequestJWTByGet")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RequestJWTByGetResponseObject); ok {
		return validResponse.VisitRequestJWTByGetResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// RequestJWTByPost operation middleware
func (sh *strictHandler) RequestJWTByPost(ctx echo.Context, subjectID string, id string) error {
	var request RequestJWTByPostRequestObject

	request.SubjectID = subjectID
	request.Id = id

	if form, err := ctx.FormParams(); err == nil {
		var body RequestJWTByPostFormdataRequestBody
		if err := runtime.BindForm(&body, form, nil, nil); err != nil {
			return err
		}
		request.Body = &body
	} else {
		return err
	}

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.RequestJWTByPost(ctx.Request().Context(), request.(RequestJWTByPostRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "RequestJWTByPost")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(RequestJWTByPostResponseObject); ok {
		return validResponse.VisitRequestJWTByPostResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// HandleAuthorizeResponse operation middleware
func (sh *strictHandler) HandleAuthorizeResponse(ctx echo.Context, subjectID string) error {
	var request HandleAuthorizeResponseRequestObject

	request.SubjectID = subjectID

	if form, err := ctx.FormParams(); err == nil {
		var body HandleAuthorizeResponseFormdataRequestBody
		if err := runtime.BindForm(&body, form, nil, nil); err != nil {
			return err
		}
		request.Body = &body
	} else {
		return err
	}

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.HandleAuthorizeResponse(ctx.Request().Context(), request.(HandleAuthorizeResponseRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "HandleAuthorizeResponse")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(HandleAuthorizeResponseResponseObject); ok {
		return validResponse.VisitHandleAuthorizeResponseResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// HandleTokenRequest operation middleware
func (sh *strictHandler) HandleTokenRequest(ctx echo.Context, subjectID string) error {
	var request HandleTokenRequestRequestObject

	request.SubjectID = subjectID

	if form, err := ctx.FormParams(); err == nil {
		var body HandleTokenRequestFormdataRequestBody
		if err := runtime.BindForm(&body, form, nil, nil); err != nil {
			return err
		}
		request.Body = &body
	} else {
		return err
	}

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.HandleTokenRequest(ctx.Request().Context(), request.(HandleTokenRequestRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "HandleTokenRequest")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(HandleTokenRequestResponseObject); ok {
		return validResponse.VisitHandleTokenRequestResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// StatusList operation middleware
func (sh *strictHandler) StatusList(ctx echo.Context, did string, page int) error {
	var request StatusListRequestObject

	request.Did = did
	request.Page = page

	handler := func(ctx echo.Context, request interface{}) (interface{}, error) {
		return sh.ssi.StatusList(ctx.Request().Context(), request.(StatusListRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "StatusList")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(StatusListResponseObject); ok {
		return validResponse.VisitStatusListResponse(ctx.Response())
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}