// Package routes provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/deepmap/oapi-codegen version v1.16.3 DO NOT EDIT.
package routes

import (
	"bytes"
	"compress/gzip"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/labstack/echo/v4"
	"github.com/oapi-codegen/runtime"
	strictecho "github.com/oapi-codegen/runtime/strictmiddleware/echo"
)

// Account Information about an account and its balance
type Account struct {
	// Balance balance in base units for each currency
	Balance []Amount `json:"balance"`

	// Id account id as registered at the Certificate Authority
	Id string `json:"id"`
}

// Amount The amount to issue, transfer or redeem.
type Amount struct {
	// Code the code of the token
	Code string `json:"code"`

	// Value value in base units (usually cents)
	Value int64 `json:"value"`
}

// Counterparty The counterparty in a Transfer or Issuance transaction.
type Counterparty struct {
	Account string `json:"account"`

	// Node The node that holds the recipient account
	Node string `json:"node"`
}

// Error defines model for Error.
type Error struct {
	// Message High level error message
	Message string `json:"message"`

	// Payload Details about the error
	Payload string `json:"payload"`
}

// RedeemRequest Instructions to redeem tokens from an account
type RedeemRequest struct {
	// Amount The amount to issue, transfer or redeem.
	Amount Amount `json:"amount"`

	// Message optional message that will be visible to the auditor
	Message *string `json:"message,omitempty"`
}

// TransactionRecord A transaction
type TransactionRecord struct {
	// Amount The amount to issue, transfer or redeem.
	Amount Amount `json:"amount"`

	// Id transaction id
	Id string `json:"id"`

	// Message user provided message
	Message string `json:"message"`

	// Recipient the recipient of the transaction
	Recipient string `json:"recipient"`

	// Sender the sender of the transaction
	Sender string `json:"sender"`

	// Status Unknown | Pending | Confirmed | Deleted
	Status string `json:"status"`

	// Timestamp timestamp in the format: "2018-03-20T09:12:28Z"
	Timestamp time.Time `json:"timestamp"`
}

// TransferRequest Instructions to issue or transfer tokens to an account
type TransferRequest struct {
	// Amount The amount to issue, transfer or redeem.
	Amount Amount `json:"amount"`

	// Counterparty The counterparty in a Transfer or Issuance transaction.
	Counterparty Counterparty `json:"counterparty"`

	// Message optional message that will be sent and stored with the transfer transaction
	Message *string `json:"message,omitempty"`
}

// Code The token code to filter on
type Code = string

// Id account id as registered at the Certificate Authority
type Id = string

// AccountSuccess defines model for AccountSuccess.
type AccountSuccess struct {
	Message string `json:"message"`

	// Payload Information about an account and its balance
	Payload Account `json:"payload"`
}

// AccountsSuccess defines model for AccountsSuccess.
type AccountsSuccess struct {
	Message string    `json:"message"`
	Payload []Account `json:"payload"`
}

// ErrorResponse defines model for ErrorResponse.
type ErrorResponse = Error

// HealthSuccess defines model for HealthSuccess.
type HealthSuccess struct {
	// Message ok
	Message string `json:"message"`
}

// RedeemSuccess defines model for RedeemSuccess.
type RedeemSuccess struct {
	Message string `json:"message"`

	// Payload Transaction id
	Payload string `json:"payload"`
}

// TransactionsSuccess defines model for TransactionsSuccess.
type TransactionsSuccess struct {
	Message string              `json:"message"`
	Payload []TransactionRecord `json:"payload"`
}

// TransferSuccess defines model for TransferSuccess.
type TransferSuccess struct {
	Message string `json:"message"`

	// Payload Transaction id
	Payload string `json:"payload"`
}

// OwnerAccountParams defines parameters for OwnerAccount.
type OwnerAccountParams struct {
	Code *Code `form:"code,omitempty" json:"code,omitempty"`
}

// RedeemJSONRequestBody defines body for Redeem for application/json ContentType.
type RedeemJSONRequestBody = RedeemRequest

// TransferJSONRequestBody defines body for Transfer for application/json ContentType.
type TransferJSONRequestBody = TransferRequest

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Returns 200 if the service is healthy
	// (GET /healthz)
	Healthz(ctx echo.Context) error
	// Get all accounts on this node and their balances of each type
	// (GET /owner/accounts)
	OwnerAccounts(ctx echo.Context) error
	// Get an account and its balances of each token type
	// (GET /owner/accounts/{id})
	OwnerAccount(ctx echo.Context, id Id, params OwnerAccountParams) error
	// Redeem (burn) tokens
	// (POST /owner/accounts/{id}/redeem)
	Redeem(ctx echo.Context, id Id) error
	// Get all transactions for an account
	// (GET /owner/accounts/{id}/transactions)
	OwnerTransactions(ctx echo.Context, id Id) error
	// Transfer tokens to another account
	// (POST /owner/accounts/{id}/transfer)
	Transfer(ctx echo.Context, id Id) error
	// Returns 200 if the service is ready to accept calls
	// (GET /readyz)
	Readyz(ctx echo.Context) error
}

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

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

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

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

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

// OwnerAccount converts echo context to params.
func (w *ServerInterfaceWrapper) OwnerAccount(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "id" -------------
	var id Id

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

	// Parameter object where we will unmarshal all parameters from the context
	var params OwnerAccountParams
	// ------------- 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))
	}

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

// Redeem converts echo context to params.
func (w *ServerInterfaceWrapper) Redeem(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "id" -------------
	var id Id

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

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

// OwnerTransactions converts echo context to params.
func (w *ServerInterfaceWrapper) OwnerTransactions(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "id" -------------
	var id Id

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

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

// Transfer converts echo context to params.
func (w *ServerInterfaceWrapper) Transfer(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "id" -------------
	var id Id

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.Readyz(ctx)
	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+"/healthz", wrapper.Healthz)
	router.GET(baseURL+"/owner/accounts", wrapper.OwnerAccounts)
	router.GET(baseURL+"/owner/accounts/:id", wrapper.OwnerAccount)
	router.POST(baseURL+"/owner/accounts/:id/redeem", wrapper.Redeem)
	router.GET(baseURL+"/owner/accounts/:id/transactions", wrapper.OwnerTransactions)
	router.POST(baseURL+"/owner/accounts/:id/transfer", wrapper.Transfer)
	router.GET(baseURL+"/readyz", wrapper.Readyz)

}

type AccountSuccessJSONResponse struct {
	Message string `json:"message"`

	// Payload Information about an account and its balance
	Payload Account `json:"payload"`
}

type AccountsSuccessJSONResponse struct {
	Message string    `json:"message"`
	Payload []Account `json:"payload"`
}

type ErrorResponseJSONResponse Error

type HealthSuccessJSONResponse struct {
	// Message ok
	Message string `json:"message"`
}

type RedeemSuccessJSONResponse struct {
	Message string `json:"message"`

	// Payload Transaction id
	Payload string `json:"payload"`
}

type TransactionsSuccessJSONResponse struct {
	Message string              `json:"message"`
	Payload []TransactionRecord `json:"payload"`
}

type TransferSuccessJSONResponse struct {
	Message string `json:"message"`

	// Payload Transaction id
	Payload string `json:"payload"`
}

type HealthzRequestObject struct {
}

type HealthzResponseObject interface {
	VisitHealthzResponse(w http.ResponseWriter) error
}

type Healthz200JSONResponse struct{ HealthSuccessJSONResponse }

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

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

type Healthz503JSONResponse struct{ ErrorResponseJSONResponse }

func (response Healthz503JSONResponse) VisitHealthzResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(503)

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

type OwnerAccountsRequestObject struct {
}

type OwnerAccountsResponseObject interface {
	VisitOwnerAccountsResponse(w http.ResponseWriter) error
}

type OwnerAccounts200JSONResponse struct{ AccountsSuccessJSONResponse }

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

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

type OwnerAccountsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

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

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

type OwnerAccountRequestObject struct {
	Id     Id `json:"id"`
	Params OwnerAccountParams
}

type OwnerAccountResponseObject interface {
	VisitOwnerAccountResponse(w http.ResponseWriter) error
}

type OwnerAccount200JSONResponse struct{ AccountSuccessJSONResponse }

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

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

type OwnerAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

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

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

type RedeemRequestObject struct {
	Id   Id `json:"id"`
	Body *RedeemJSONRequestBody
}

type RedeemResponseObject interface {
	VisitRedeemResponse(w http.ResponseWriter) error
}

type Redeem200JSONResponse struct{ RedeemSuccessJSONResponse }

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

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

type RedeemdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

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

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

type OwnerTransactionsRequestObject struct {
	Id Id `json:"id"`
}

type OwnerTransactionsResponseObject interface {
	VisitOwnerTransactionsResponse(w http.ResponseWriter) error
}

type OwnerTransactions200JSONResponse struct {
	TransactionsSuccessJSONResponse
}

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

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

type OwnerTransactionsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

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

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

type TransferRequestObject struct {
	Id   Id `json:"id"`
	Body *TransferJSONRequestBody
}

type TransferResponseObject interface {
	VisitTransferResponse(w http.ResponseWriter) error
}

type Transfer200JSONResponse struct{ TransferSuccessJSONResponse }

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

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

type TransferdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

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

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

type ReadyzRequestObject struct {
}

type ReadyzResponseObject interface {
	VisitReadyzResponse(w http.ResponseWriter) error
}

type Readyz200JSONResponse struct{ HealthSuccessJSONResponse }

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

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

type Readyz503JSONResponse struct{ ErrorResponseJSONResponse }

func (response Readyz503JSONResponse) VisitReadyzResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(503)

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

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// Returns 200 if the service is healthy
	// (GET /healthz)
	Healthz(ctx context.Context, request HealthzRequestObject) (HealthzResponseObject, error)
	// Get all accounts on this node and their balances of each type
	// (GET /owner/accounts)
	OwnerAccounts(ctx context.Context, request OwnerAccountsRequestObject) (OwnerAccountsResponseObject, error)
	// Get an account and its balances of each token type
	// (GET /owner/accounts/{id})
	OwnerAccount(ctx context.Context, request OwnerAccountRequestObject) (OwnerAccountResponseObject, error)
	// Redeem (burn) tokens
	// (POST /owner/accounts/{id}/redeem)
	Redeem(ctx context.Context, request RedeemRequestObject) (RedeemResponseObject, error)
	// Get all transactions for an account
	// (GET /owner/accounts/{id}/transactions)
	OwnerTransactions(ctx context.Context, request OwnerTransactionsRequestObject) (OwnerTransactionsResponseObject, error)
	// Transfer tokens to another account
	// (POST /owner/accounts/{id}/transfer)
	Transfer(ctx context.Context, request TransferRequestObject) (TransferResponseObject, error)
	// Returns 200 if the service is ready to accept calls
	// (GET /readyz)
	Readyz(ctx context.Context, request ReadyzRequestObject) (ReadyzResponseObject, 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
}

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

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

	response, err := handler(ctx, request)

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

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

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

	response, err := handler(ctx, request)

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

// OwnerAccount operation middleware
func (sh *strictHandler) OwnerAccount(ctx echo.Context, id Id, params OwnerAccountParams) error {
	var request OwnerAccountRequestObject

	request.Id = id
	request.Params = params

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

	response, err := handler(ctx, request)

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

// Redeem operation middleware
func (sh *strictHandler) Redeem(ctx echo.Context, id Id) error {
	var request RedeemRequestObject

	request.Id = id

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

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

	response, err := handler(ctx, request)

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

// OwnerTransactions operation middleware
func (sh *strictHandler) OwnerTransactions(ctx echo.Context, id Id) error {
	var request OwnerTransactionsRequestObject

	request.Id = id

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

	response, err := handler(ctx, request)

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

// Transfer operation middleware
func (sh *strictHandler) Transfer(ctx echo.Context, id Id) error {
	var request TransferRequestObject

	request.Id = id

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

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

	response, err := handler(ctx, request)

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

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

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

	response, err := handler(ctx, request)

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

// Base64 encoded, gzipped, json marshaled Swagger object
var swaggerSpec = []string{

	"H4sIAAAAAAAC/+Ra64/buBH/V6ZsgSaAzpa9ty9/y12uTVCgCTYb9HDxfqDFkcVbiVRIyls38f9e8KGX",
	"LXudzV6Q5D4ltujhzG9evxntB5LIopQChdFk9oGUVNECDSr3KZEM7b9ckBl5X6Fak4gIWiCZ+WcR0UmG",
	"BbWHGOpE8dJwaU9fZwhG3qIAexCMhJTnBhVIQSKC/6VFmVsxv7y9+pVExKxL+0kbxcWSbDYR4ay5uaQm",
	"ay/mjERE4fuKK2RkZlSF+9WgSSIrYYAzoBoULrk2qJABNWAyhJ9RGZ7yhBqEZ5XJpOJm3VOQ5jzBAQ03",
	"VgldSqHRYfXM3/SmShLUAT1hUBj7X1qWub2ESzH+XVvNPnRULpUsrR5eUIFa06XDfevOiJR0nUvqkPmb",
	"wpTMyF/HrQPHXqQeB12IV7JG6l0juhV00xgmF79jYrxhfQyDSVCbaxUJN+gvZi43WOij7W6sokrR9R+I",
	"wy9KSXVVf/EpKByyw0kdUsE96CnwAmlusoe4oQnxjg+IvHW47/NQXxt5O5i5Q0g/FN8rZIjFo0ZZm9qu",
	"Ptn77B3Ido3pReBWfVNUaJrYT+AqUiv2PJmeITvDU4xP03OGFxN6MT27nCzOzhaT+OySTU7jc3aJLD1J",
	"zhfnF0gnKb28OD09Rzw9X/x4NKifH74dK/QfBXLnClBoFMfVvVgfle0d5a8wkYp9wbx3d6eojgdtMN1M",
	"EGM7ko/Gjm6PEEmb6HPr7j1R/2UCtTGj22l3tXspUqkKBzvQhawMUAE1A6CCATcaFjSnwnX0jkfqL2fv",
	"atJTE5MVzSsks0kcx/Emap6+ffO883Qax5sbT1kCX9gpos0N20qHB8AFLKhGqITVMpUKkCYZJJVSKBLL",
	"SY5rgcVwB6wJ1ZeiR/1AcLFSQ7AbAxEJag/SSOqeWQrJta4wgjprwPVCW7xHfXfuc+GOV2qCyzClVW7a",
	"3/S1sFA4GitTB4tL1aESFq7atsJ9veXhJ5WuaJ6vIbH+e0oi4oPXMlxhzmwXKLjgRVWQWdxcxYXBJaod",
	"gAMb9/cPAfyzxRBVSZVZD8OcdE5YXSlcd3B+qXXl4rRTz7dQp3VeNkEhvB/knUA12c0J2ibyDpKi8cy2",
	"nsLNExk1kMmcaecQhQkvOdo0DzLvi0jhAauPD0HmWdi+0o2Oiu1WuBn5BAb1gi8zyHGFOWzLO74oP0dD",
	"ea5DybNwOFmPUp1rBnaF7yvUgzVXG1WF9m5kyMfQzCBVsugUYbITAU3aH1fT9lNR9x+a1wD6ALnjeQ4L",
	"hBXXfJG7KdTCQyvGzREABe2GUNnlHjsqPeumylamNGYfqFS2Xk+mJx2jiRt8Q6Tb1iEXdgJHwVB1sk4b",
	"aipNZuRnKVKuArPlBWpDi5LMyDSeXPwQn/wwja/jy9lkOpte/DaQnZ/om6H+Yu7hCwc8WmlUUCq54gzZ",
	"obzoIPJhoG63paEu3j2v7Iir4RyS5Z8dKyi4YVvQW3Er5J2Aj/AaBeNiCR+h8RR8hOeYoxlmyB0n7qhX",
	"P7Kl22rnu8kM5oPunpNuw2HU4A9WwnGNPEDUhT6qw6WrZINBdGAObLn00TXG0QDblBoiEMqNkY9ZbJKt",
	"lnnoV732+vBCpTEwVW2kpWF33GRtrDlLDwXdDinoKBXtL2du3SZSOYC8J1y20XZol1WwV+dH8BNNbpHB",
	"Yg0UGLf6LCqDDHJkS1TRXJQKNaqVDfdS8RVN1lBp++k3VBL+JeSdOwqvlZSpHsF1xjU8e/0SGKZccFdB",
	"UiWF0fAjMJ6mqCxWTmaCOoK7jCeZ58xlTr0e4dRcKJljnRiYSL3WBosRzMVcXEswag3cgKxMBDn6Fuos",
	"VyHUtCwQ0kowF2JSNETQFik9gv9Qk3g/BY6r52KJBqrSZhbzHkXcrhqQcevn9ahlWtz4IJYms0D7SI5a",
	"ojsXDf90ujDURsm1lexIsOHG0fLrephcodLel5NRbCNTlihoycmMnIzi0Ynr/iZzCTIOjXEc7tXjD5xt",
	"3MSPauV2wu92Joiml1YqJzOSGVPOxuNcJjTPpDazyziOx7Tk49VkTDY3m2jPNePuouDx78zcnux/VvAS",
	"XRGwpcHNii8taXsRnm9tdadxvC/1m3Pj/g5uE5HT+OT+X/VXh27GrYqCqjWZkSs0lRIapnEM3IdaiHTg",
	"GrwtNqUNXVqAWls0ubGSxi5ulf/nMJj+5AEsJz0su1q6HBmuvVYHR/sbJ+9F/pU9Vu+TH4T/9jLabRTC",
	"QPcAL+yPO0uwXDJ75rUPsWkXsWhbSkJVLrUTw6g4IOZkL/D/RAM0z2u0NUhb2rj2s5GVbDLkqqlGtly5",
	"yugKfydsLPTk5us1ejeMmpJ0byy5yta+zXo3HAntkTFnTvF7TjnGbt3x4Dj9c4Xp3g1cJyrde8LvJDbH",
	"vlG7havUAzHqB+oHReeN53eozU+SrR/tdVN/xN/0aaRRFW4eEu39VzfffbB7c+HJolLiabvM/2bC+V5b",
	"9sX7Nm8Lhbmv1L+lCaOO4zKOf1v2rOGt0KVl8t1XC68qU1ZGw5O317++ejqai39IBbQZQCJYy+rveQ4y",
	"NSg8s76T0HvT1ExOmhYInNmJwvN10CUmPOWWl/vN8lJawh6WQ92hKfLM3bL/QMj9D574xUJBuXADDVXN",
	"doGLsjIesqdOMCxochs2T3PhR+e/uMHDNuxEVjmzk18iReoHotTZajUdwTPQvChzO4Hkld+i6O7fUoR9",
	"337L6xvDzBbG9dHcxsVA6+y+D3x4hfrUSjH0FvJPw+F6vnO+724wvvluWOfs/n5Yz75fU0fcXkk9Vk/c",
	"fm383Uf59dCGrrfc+FZ75BGW2ZxQSNl6/9rhyj/+FrYOzhJnZpJgaSChea737iAOO/HTFjjR5+0soq8s",
	"hgJgu/IEJAqpaVYqMgUq1nDLBQtMBP1oX7g1pM2WZgXQ+ftID84Qaj2Xhleo2vivb3HtjWmXCinY+9yO",
	"sxXvk3RX+hKNSwLLxnCFat3bdIbda5IjVd6WW8RSA613oO0FdXDsXvEmaO73X4HSUMaFTYBWwTYONzeb",
	"/wcAAP//QP9j4uEqAAA=",
}

// GetSwagger returns the content of the embedded swagger specification file
// or error if failed to decode
func decodeSpec() ([]byte, error) {
	zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
	if err != nil {
		return nil, fmt.Errorf("error base64 decoding spec: %w", err)
	}
	zr, err := gzip.NewReader(bytes.NewReader(zipped))
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}
	var buf bytes.Buffer
	_, err = buf.ReadFrom(zr)
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %w", err)
	}

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

// a naive cached of a decoded swagger spec
func decodeSpecCached() func() ([]byte, error) {
	data, err := decodeSpec()
	return func() ([]byte, error) {
		return data, err
	}
}

// Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
	res := make(map[string]func() ([]byte, error))
	if len(pathToFile) > 0 {
		res[pathToFile] = rawSpec
	}

	return res
}

// GetSwagger returns the Swagger specification corresponding to the generated code
// in this file. The external references of Swagger specification are resolved.
// The logic of resolving external references is tightly connected to "import-mapping" feature.
// Externally referenced files must be embedded in the corresponding golang packages.
// Urls can be supported but this task was out of the scope.
func GetSwagger() (swagger *openapi3.T, err error) {
	resolvePath := PathToRawSpec("")

	loader := openapi3.NewLoader()
	loader.IsExternalRefsAllowed = true
	loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
		pathToFile := url.String()
		pathToFile = path.Clean(pathToFile)
		getSpec, ok := resolvePath[pathToFile]
		if !ok {
			err1 := fmt.Errorf("path not found: %s", pathToFile)
			return nil, err1
		}
		return getSpec()
	}
	var specData []byte
	specData, err = rawSpec()
	if err != nil {
		return
	}
	swagger, err = loader.LoadFromData(specData)
	if err != nil {
		return
	}
	return
}