path: root/backend/api/generated.go

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

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

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

// Defines values for GameState.
const (
	GameStateClosed         GameState = "closed"
	GameStateFinished       GameState = "finished"
	GameStateGaming         GameState = "gaming"
	GameStatePrepare        GameState = "prepare"
	GameStateStarting       GameState = "starting"
	GameStateWaitingEntries GameState = "waiting_entries"
	GameStateWaitingStart   GameState = "waiting_start"
)

// Defines values for GamePlayerMessageS2CExecResultPayloadStatus.
const (
	GamePlayerMessageS2CExecResultPayloadStatusSuccess GamePlayerMessageS2CExecResultPayloadStatus = "success"
)

// Defines values for GameWatcherMessageS2CExecResultPayloadStatus.
const (
	GameWatcherMessageS2CExecResultPayloadStatusSuccess GameWatcherMessageS2CExecResultPayloadStatus = "success"
)

// Defines values for PutAdminGamesGameIdJSONBodyState.
const (
	PutAdminGamesGameIdJSONBodyStateClosed         PutAdminGamesGameIdJSONBodyState = "closed"
	PutAdminGamesGameIdJSONBodyStateFinished       PutAdminGamesGameIdJSONBodyState = "finished"
	PutAdminGamesGameIdJSONBodyStateGaming         PutAdminGamesGameIdJSONBodyState = "gaming"
	PutAdminGamesGameIdJSONBodyStatePrepare        PutAdminGamesGameIdJSONBodyState = "prepare"
	PutAdminGamesGameIdJSONBodyStateStarting       PutAdminGamesGameIdJSONBodyState = "starting"
	PutAdminGamesGameIdJSONBodyStateWaitingEntries PutAdminGamesGameIdJSONBodyState = "waiting_entries"
	PutAdminGamesGameIdJSONBodyStateWaitingStart   PutAdminGamesGameIdJSONBodyState = "waiting_start"
)

// Game defines model for Game.
type Game struct {
	DisplayName     string    `json:"display_name"`
	DurationSeconds int       `json:"duration_seconds"`
	GameId          int       `json:"game_id"`
	Problem         *Problem  `json:"problem,omitempty"`
	StartedAt       *int      `json:"started_at,omitempty"`
	State           GameState `json:"state"`
}

// GameState defines model for Game.State.
type GameState string

// GamePlayerMessage defines model for GamePlayerMessage.
type GamePlayerMessage struct {
	union json.RawMessage
}

// GamePlayerMessageC2S defines model for GamePlayerMessageC2S.
type GamePlayerMessageC2S struct {
	union json.RawMessage
}

// GamePlayerMessageC2SCode defines model for GamePlayerMessageC2SCode.
type GamePlayerMessageC2SCode struct {
	Data GamePlayerMessageC2SCodePayload `json:"data"`
	Type string                          `json:"type"`
}

// GamePlayerMessageC2SCodePayload defines model for GamePlayerMessageC2SCodePayload.
type GamePlayerMessageC2SCodePayload struct {
	Code string `json:"code"`
}

// GamePlayerMessageC2SEntry defines model for GamePlayerMessageC2SEntry.
type GamePlayerMessageC2SEntry struct {
	Type string `json:"type"`
}

// GamePlayerMessageC2SReady defines model for GamePlayerMessageC2SReady.
type GamePlayerMessageC2SReady struct {
	Type string `json:"type"`
}

// GamePlayerMessageS2C defines model for GamePlayerMessageS2C.
type GamePlayerMessageS2C struct {
	union json.RawMessage
}

// GamePlayerMessageS2CExecResult defines model for GamePlayerMessageS2CExecResult.
type GamePlayerMessageS2CExecResult struct {
	Data GamePlayerMessageS2CExecResultPayload `json:"data"`
	Type string                                `json:"type"`
}

// GamePlayerMessageS2CExecResultPayload defines model for GamePlayerMessageS2CExecResultPayload.
type GamePlayerMessageS2CExecResultPayload struct {
	Score  nullable.Nullable[int]                      `json:"score"`
	Status GamePlayerMessageS2CExecResultPayloadStatus `json:"status"`
}

// GamePlayerMessageS2CExecResultPayloadStatus defines model for GamePlayerMessageS2CExecResultPayload.Status.
type GamePlayerMessageS2CExecResultPayloadStatus string

// GamePlayerMessageS2CPrepare defines model for GamePlayerMessageS2CPrepare.
type GamePlayerMessageS2CPrepare struct {
	Data GamePlayerMessageS2CPreparePayload `json:"data"`
	Type string                             `json:"type"`
}

// GamePlayerMessageS2CPreparePayload defines model for GamePlayerMessageS2CPreparePayload.
type GamePlayerMessageS2CPreparePayload struct {
	Problem Problem `json:"problem"`
}

// GamePlayerMessageS2CStart defines model for GamePlayerMessageS2CStart.
type GamePlayerMessageS2CStart struct {
	Data GamePlayerMessageS2CStartPayload `json:"data"`
	Type string                           `json:"type"`
}

// GamePlayerMessageS2CStartPayload defines model for GamePlayerMessageS2CStartPayload.
type GamePlayerMessageS2CStartPayload struct {
	StartAt int `json:"start_at"`
}

// GameWatcherMessage defines model for GameWatcherMessage.
type GameWatcherMessage struct {
	union json.RawMessage
}

// GameWatcherMessageS2C defines model for GameWatcherMessageS2C.
type GameWatcherMessageS2C struct {
	union json.RawMessage
}

// GameWatcherMessageS2CCode defines model for GameWatcherMessageS2CCode.
type GameWatcherMessageS2CCode struct {
	Data GameWatcherMessageS2CCodePayload `json:"data"`
	Type string                           `json:"type"`
}

// GameWatcherMessageS2CCodePayload defines model for GameWatcherMessageS2CCodePayload.
type GameWatcherMessageS2CCodePayload struct {
	Code     string `json:"code"`
	PlayerId int    `json:"player_id"`
}

// GameWatcherMessageS2CExecResult defines model for GameWatcherMessageS2CExecResult.
type GameWatcherMessageS2CExecResult struct {
	Data GameWatcherMessageS2CExecResultPayload `json:"data"`
	Type string                                 `json:"type"`
}

// GameWatcherMessageS2CExecResultPayload defines model for GameWatcherMessageS2CExecResultPayload.
type GameWatcherMessageS2CExecResultPayload struct {
	PlayerId int                                          `json:"player_id"`
	Score    nullable.Nullable[int]                       `json:"score"`
	Status   GameWatcherMessageS2CExecResultPayloadStatus `json:"status"`
	Stderr   string                                       `json:"stderr"`
	Stdout   string                                       `json:"stdout"`
}

// GameWatcherMessageS2CExecResultPayloadStatus defines model for GameWatcherMessageS2CExecResultPayload.Status.
type GameWatcherMessageS2CExecResultPayloadStatus string

// GameWatcherMessageS2CStart defines model for GameWatcherMessageS2CStart.
type GameWatcherMessageS2CStart struct {
	Data GameWatcherMessageS2CStartPayload `json:"data"`
	Type string                            `json:"type"`
}

// GameWatcherMessageS2CStartPayload defines model for GameWatcherMessageS2CStartPayload.
type GameWatcherMessageS2CStartPayload struct {
	StartAt int `json:"start_at"`
}

// Problem defines model for Problem.
type Problem struct {
	Description string `json:"description"`
	ProblemId   int    `json:"problem_id"`
	Title       string `json:"title"`
}

// User defines model for User.
type User struct {
	DisplayName string  `json:"display_name"`
	IconPath    *string `json:"icon_path,omitempty"`
	IsAdmin     bool    `json:"is_admin"`
	UserId      int     `json:"user_id"`
	Username    string  `json:"username"`
}

// GetAdminGamesParams defines parameters for GetAdminGames.
type GetAdminGamesParams struct {
	Authorization string `json:"Authorization"`
}

// GetAdminGamesGameIdParams defines parameters for GetAdminGamesGameId.
type GetAdminGamesGameIdParams struct {
	Authorization string `json:"Authorization"`
}

// PutAdminGamesGameIdJSONBody defines parameters for PutAdminGamesGameId.
type PutAdminGamesGameIdJSONBody struct {
	DisplayName     *string                           `json:"display_name,omitempty"`
	DurationSeconds *int                              `json:"duration_seconds,omitempty"`
	ProblemId       nullable.Nullable[int]            `json:"problem_id,omitempty"`
	StartedAt       nullable.Nullable[int]            `json:"started_at,omitempty"`
	State           *PutAdminGamesGameIdJSONBodyState `json:"state,omitempty"`
}

// PutAdminGamesGameIdParams defines parameters for PutAdminGamesGameId.
type PutAdminGamesGameIdParams struct {
	Authorization string `json:"Authorization"`
}

// PutAdminGamesGameIdJSONBodyState defines parameters for PutAdminGamesGameId.
type PutAdminGamesGameIdJSONBodyState string

// GetAdminUsersParams defines parameters for GetAdminUsers.
type GetAdminUsersParams struct {
	Authorization string `json:"Authorization"`
}

// GetGamesParams defines parameters for GetGames.
type GetGamesParams struct {
	PlayerId      *int   `form:"player_id,omitempty" json:"player_id,omitempty"`
	Authorization string `json:"Authorization"`
}

// GetGamesGameIdParams defines parameters for GetGamesGameId.
type GetGamesGameIdParams struct {
	Authorization string `json:"Authorization"`
}

// PostLoginJSONBody defines parameters for PostLogin.
type PostLoginJSONBody struct {
	Password string `json:"password"`
	Username string `json:"username"`
}

// GetTokenParams defines parameters for GetToken.
type GetTokenParams struct {
	Authorization string `json:"Authorization"`
}

// PutAdminGamesGameIdJSONRequestBody defines body for PutAdminGamesGameId for application/json ContentType.
type PutAdminGamesGameIdJSONRequestBody PutAdminGamesGameIdJSONBody

// PostLoginJSONRequestBody defines body for PostLogin for application/json ContentType.
type PostLoginJSONRequestBody PostLoginJSONBody

// AsGamePlayerMessageS2C returns the union data inside the GamePlayerMessage as a GamePlayerMessageS2C
func (t GamePlayerMessage) AsGamePlayerMessageS2C() (GamePlayerMessageS2C, error) {
	var body GamePlayerMessageS2C
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageS2C overwrites any union data inside the GamePlayerMessage as the provided GamePlayerMessageS2C
func (t *GamePlayerMessage) FromGamePlayerMessageS2C(v GamePlayerMessageS2C) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageS2C performs a merge with any union data inside the GamePlayerMessage, using the provided GamePlayerMessageS2C
func (t *GamePlayerMessage) MergeGamePlayerMessageS2C(v GamePlayerMessageS2C) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGamePlayerMessageC2S returns the union data inside the GamePlayerMessage as a GamePlayerMessageC2S
func (t GamePlayerMessage) AsGamePlayerMessageC2S() (GamePlayerMessageC2S, error) {
	var body GamePlayerMessageC2S
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageC2S overwrites any union data inside the GamePlayerMessage as the provided GamePlayerMessageC2S
func (t *GamePlayerMessage) FromGamePlayerMessageC2S(v GamePlayerMessageC2S) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageC2S performs a merge with any union data inside the GamePlayerMessage, using the provided GamePlayerMessageC2S
func (t *GamePlayerMessage) MergeGamePlayerMessageC2S(v GamePlayerMessageC2S) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t GamePlayerMessage) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *GamePlayerMessage) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsGamePlayerMessageC2SEntry returns the union data inside the GamePlayerMessageC2S as a GamePlayerMessageC2SEntry
func (t GamePlayerMessageC2S) AsGamePlayerMessageC2SEntry() (GamePlayerMessageC2SEntry, error) {
	var body GamePlayerMessageC2SEntry
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageC2SEntry overwrites any union data inside the GamePlayerMessageC2S as the provided GamePlayerMessageC2SEntry
func (t *GamePlayerMessageC2S) FromGamePlayerMessageC2SEntry(v GamePlayerMessageC2SEntry) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageC2SEntry performs a merge with any union data inside the GamePlayerMessageC2S, using the provided GamePlayerMessageC2SEntry
func (t *GamePlayerMessageC2S) MergeGamePlayerMessageC2SEntry(v GamePlayerMessageC2SEntry) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGamePlayerMessageC2SReady returns the union data inside the GamePlayerMessageC2S as a GamePlayerMessageC2SReady
func (t GamePlayerMessageC2S) AsGamePlayerMessageC2SReady() (GamePlayerMessageC2SReady, error) {
	var body GamePlayerMessageC2SReady
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageC2SReady overwrites any union data inside the GamePlayerMessageC2S as the provided GamePlayerMessageC2SReady
func (t *GamePlayerMessageC2S) FromGamePlayerMessageC2SReady(v GamePlayerMessageC2SReady) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageC2SReady performs a merge with any union data inside the GamePlayerMessageC2S, using the provided GamePlayerMessageC2SReady
func (t *GamePlayerMessageC2S) MergeGamePlayerMessageC2SReady(v GamePlayerMessageC2SReady) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGamePlayerMessageC2SCode returns the union data inside the GamePlayerMessageC2S as a GamePlayerMessageC2SCode
func (t GamePlayerMessageC2S) AsGamePlayerMessageC2SCode() (GamePlayerMessageC2SCode, error) {
	var body GamePlayerMessageC2SCode
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageC2SCode overwrites any union data inside the GamePlayerMessageC2S as the provided GamePlayerMessageC2SCode
func (t *GamePlayerMessageC2S) FromGamePlayerMessageC2SCode(v GamePlayerMessageC2SCode) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageC2SCode performs a merge with any union data inside the GamePlayerMessageC2S, using the provided GamePlayerMessageC2SCode
func (t *GamePlayerMessageC2S) MergeGamePlayerMessageC2SCode(v GamePlayerMessageC2SCode) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t GamePlayerMessageC2S) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *GamePlayerMessageC2S) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsGamePlayerMessageS2CPrepare returns the union data inside the GamePlayerMessageS2C as a GamePlayerMessageS2CPrepare
func (t GamePlayerMessageS2C) AsGamePlayerMessageS2CPrepare() (GamePlayerMessageS2CPrepare, error) {
	var body GamePlayerMessageS2CPrepare
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageS2CPrepare overwrites any union data inside the GamePlayerMessageS2C as the provided GamePlayerMessageS2CPrepare
func (t *GamePlayerMessageS2C) FromGamePlayerMessageS2CPrepare(v GamePlayerMessageS2CPrepare) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageS2CPrepare performs a merge with any union data inside the GamePlayerMessageS2C, using the provided GamePlayerMessageS2CPrepare
func (t *GamePlayerMessageS2C) MergeGamePlayerMessageS2CPrepare(v GamePlayerMessageS2CPrepare) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGamePlayerMessageS2CStart returns the union data inside the GamePlayerMessageS2C as a GamePlayerMessageS2CStart
func (t GamePlayerMessageS2C) AsGamePlayerMessageS2CStart() (GamePlayerMessageS2CStart, error) {
	var body GamePlayerMessageS2CStart
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageS2CStart overwrites any union data inside the GamePlayerMessageS2C as the provided GamePlayerMessageS2CStart
func (t *GamePlayerMessageS2C) FromGamePlayerMessageS2CStart(v GamePlayerMessageS2CStart) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageS2CStart performs a merge with any union data inside the GamePlayerMessageS2C, using the provided GamePlayerMessageS2CStart
func (t *GamePlayerMessageS2C) MergeGamePlayerMessageS2CStart(v GamePlayerMessageS2CStart) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGamePlayerMessageS2CExecResult returns the union data inside the GamePlayerMessageS2C as a GamePlayerMessageS2CExecResult
func (t GamePlayerMessageS2C) AsGamePlayerMessageS2CExecResult() (GamePlayerMessageS2CExecResult, error) {
	var body GamePlayerMessageS2CExecResult
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGamePlayerMessageS2CExecResult overwrites any union data inside the GamePlayerMessageS2C as the provided GamePlayerMessageS2CExecResult
func (t *GamePlayerMessageS2C) FromGamePlayerMessageS2CExecResult(v GamePlayerMessageS2CExecResult) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGamePlayerMessageS2CExecResult performs a merge with any union data inside the GamePlayerMessageS2C, using the provided GamePlayerMessageS2CExecResult
func (t *GamePlayerMessageS2C) MergeGamePlayerMessageS2CExecResult(v GamePlayerMessageS2CExecResult) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t GamePlayerMessageS2C) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *GamePlayerMessageS2C) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsGameWatcherMessageS2C returns the union data inside the GameWatcherMessage as a GameWatcherMessageS2C
func (t GameWatcherMessage) AsGameWatcherMessageS2C() (GameWatcherMessageS2C, error) {
	var body GameWatcherMessageS2C
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGameWatcherMessageS2C overwrites any union data inside the GameWatcherMessage as the provided GameWatcherMessageS2C
func (t *GameWatcherMessage) FromGameWatcherMessageS2C(v GameWatcherMessageS2C) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGameWatcherMessageS2C performs a merge with any union data inside the GameWatcherMessage, using the provided GameWatcherMessageS2C
func (t *GameWatcherMessage) MergeGameWatcherMessageS2C(v GameWatcherMessageS2C) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t GameWatcherMessage) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *GameWatcherMessage) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// AsGameWatcherMessageS2CStart returns the union data inside the GameWatcherMessageS2C as a GameWatcherMessageS2CStart
func (t GameWatcherMessageS2C) AsGameWatcherMessageS2CStart() (GameWatcherMessageS2CStart, error) {
	var body GameWatcherMessageS2CStart
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGameWatcherMessageS2CStart overwrites any union data inside the GameWatcherMessageS2C as the provided GameWatcherMessageS2CStart
func (t *GameWatcherMessageS2C) FromGameWatcherMessageS2CStart(v GameWatcherMessageS2CStart) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGameWatcherMessageS2CStart performs a merge with any union data inside the GameWatcherMessageS2C, using the provided GameWatcherMessageS2CStart
func (t *GameWatcherMessageS2C) MergeGameWatcherMessageS2CStart(v GameWatcherMessageS2CStart) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGameWatcherMessageS2CCode returns the union data inside the GameWatcherMessageS2C as a GameWatcherMessageS2CCode
func (t GameWatcherMessageS2C) AsGameWatcherMessageS2CCode() (GameWatcherMessageS2CCode, error) {
	var body GameWatcherMessageS2CCode
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGameWatcherMessageS2CCode overwrites any union data inside the GameWatcherMessageS2C as the provided GameWatcherMessageS2CCode
func (t *GameWatcherMessageS2C) FromGameWatcherMessageS2CCode(v GameWatcherMessageS2CCode) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGameWatcherMessageS2CCode performs a merge with any union data inside the GameWatcherMessageS2C, using the provided GameWatcherMessageS2CCode
func (t *GameWatcherMessageS2C) MergeGameWatcherMessageS2CCode(v GameWatcherMessageS2CCode) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

// AsGameWatcherMessageS2CExecResult returns the union data inside the GameWatcherMessageS2C as a GameWatcherMessageS2CExecResult
func (t GameWatcherMessageS2C) AsGameWatcherMessageS2CExecResult() (GameWatcherMessageS2CExecResult, error) {
	var body GameWatcherMessageS2CExecResult
	err := json.Unmarshal(t.union, &body)
	return body, err
}

// FromGameWatcherMessageS2CExecResult overwrites any union data inside the GameWatcherMessageS2C as the provided GameWatcherMessageS2CExecResult
func (t *GameWatcherMessageS2C) FromGameWatcherMessageS2CExecResult(v GameWatcherMessageS2CExecResult) error {
	b, err := json.Marshal(v)
	t.union = b
	return err
}

// MergeGameWatcherMessageS2CExecResult performs a merge with any union data inside the GameWatcherMessageS2C, using the provided GameWatcherMessageS2CExecResult
func (t *GameWatcherMessageS2C) MergeGameWatcherMessageS2CExecResult(v GameWatcherMessageS2CExecResult) error {
	b, err := json.Marshal(v)
	if err != nil {
		return err
	}

	merged, err := runtime.JSONMerge(t.union, b)
	t.union = merged
	return err
}

func (t GameWatcherMessageS2C) MarshalJSON() ([]byte, error) {
	b, err := t.union.MarshalJSON()
	return b, err
}

func (t *GameWatcherMessageS2C) UnmarshalJSON(b []byte) error {
	err := t.union.UnmarshalJSON(b)
	return err
}

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// List games
	// (GET /admin/games)
	GetAdminGames(ctx echo.Context, params GetAdminGamesParams) error
	// Get a game
	// (GET /admin/games/{game_id})
	GetAdminGamesGameId(ctx echo.Context, gameId int, params GetAdminGamesGameIdParams) error
	// Update a game
	// (PUT /admin/games/{game_id})
	PutAdminGamesGameId(ctx echo.Context, gameId int, params PutAdminGamesGameIdParams) error
	// List all users
	// (GET /admin/users)
	GetAdminUsers(ctx echo.Context, params GetAdminUsersParams) error
	// List games
	// (GET /games)
	GetGames(ctx echo.Context, params GetGamesParams) error
	// Get a game
	// (GET /games/{game_id})
	GetGamesGameId(ctx echo.Context, gameId int, params GetGamesGameIdParams) error
	// User login
	// (POST /login)
	PostLogin(ctx echo.Context) error
	// Get a short-lived access token
	// (GET /token)
	GetToken(ctx echo.Context, params GetTokenParams) error
}

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

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

// GetAdminGamesGameId converts echo context to params.
func (w *ServerInterfaceWrapper) GetAdminGamesGameId(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "game_id" -------------
	var gameId int

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

// PutAdminGamesGameId converts echo context to params.
func (w *ServerInterfaceWrapper) PutAdminGamesGameId(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "game_id" -------------
	var gameId int

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

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

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

// GetGamesGameId converts echo context to params.
func (w *ServerInterfaceWrapper) GetGamesGameId(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "game_id" -------------
	var gameId int

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

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

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

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

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

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

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

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

		params.Authorization = Authorization
	} else {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Header parameter Authorization is required, but not found"))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetToken(ctx, params)
	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+"/admin/games", wrapper.GetAdminGames)
	router.GET(baseURL+"/admin/games/:game_id", wrapper.GetAdminGamesGameId)
	router.PUT(baseURL+"/admin/games/:game_id", wrapper.PutAdminGamesGameId)
	router.GET(baseURL+"/admin/users", wrapper.GetAdminUsers)
	router.GET(baseURL+"/games", wrapper.GetGames)
	router.GET(baseURL+"/games/:game_id", wrapper.GetGamesGameId)
	router.POST(baseURL+"/login", wrapper.PostLogin)
	router.GET(baseURL+"/token", wrapper.GetToken)

}

type GetAdminGamesRequestObject struct {
	Params GetAdminGamesParams
}

type GetAdminGamesResponseObject interface {
	VisitGetAdminGamesResponse(w http.ResponseWriter) error
}

type GetAdminGames200JSONResponse struct {
	Games []Game `json:"games"`
}

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

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

type GetAdminGames403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetAdminGames403JSONResponse) VisitGetAdminGamesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type GetAdminGamesGameIdRequestObject struct {
	GameId int `json:"game_id"`
	Params GetAdminGamesGameIdParams
}

type GetAdminGamesGameIdResponseObject interface {
	VisitGetAdminGamesGameIdResponse(w http.ResponseWriter) error
}

type GetAdminGamesGameId200JSONResponse struct {
	Game Game `json:"game"`
}

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

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

type GetAdminGamesGameId403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetAdminGamesGameId403JSONResponse) VisitGetAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type GetAdminGamesGameId404JSONResponse struct {
	Message string `json:"message"`
}

func (response GetAdminGamesGameId404JSONResponse) VisitGetAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

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

type PutAdminGamesGameIdRequestObject struct {
	GameId int `json:"game_id"`
	Params PutAdminGamesGameIdParams
	Body   *PutAdminGamesGameIdJSONRequestBody
}

type PutAdminGamesGameIdResponseObject interface {
	VisitPutAdminGamesGameIdResponse(w http.ResponseWriter) error
}

type PutAdminGamesGameId204Response struct {
}

func (response PutAdminGamesGameId204Response) VisitPutAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type PutAdminGamesGameId400JSONResponse struct {
	Message string `json:"message"`
}

func (response PutAdminGamesGameId400JSONResponse) VisitPutAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(400)

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

type PutAdminGamesGameId403JSONResponse struct {
	Message string `json:"message"`
}

func (response PutAdminGamesGameId403JSONResponse) VisitPutAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type PutAdminGamesGameId404JSONResponse struct {
	Message string `json:"message"`
}

func (response PutAdminGamesGameId404JSONResponse) VisitPutAdminGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

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

type GetAdminUsersRequestObject struct {
	Params GetAdminUsersParams
}

type GetAdminUsersResponseObject interface {
	VisitGetAdminUsersResponse(w http.ResponseWriter) error
}

type GetAdminUsers200JSONResponse struct {
	Users []User `json:"users"`
}

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

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

type GetAdminUsers403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetAdminUsers403JSONResponse) VisitGetAdminUsersResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type GetGamesRequestObject struct {
	Params GetGamesParams
}

type GetGamesResponseObject interface {
	VisitGetGamesResponse(w http.ResponseWriter) error
}

type GetGames200JSONResponse struct {
	Games []Game `json:"games"`
}

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

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

type GetGames403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetGames403JSONResponse) VisitGetGamesResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type GetGamesGameIdRequestObject struct {
	GameId int `json:"game_id"`
	Params GetGamesGameIdParams
}

type GetGamesGameIdResponseObject interface {
	VisitGetGamesGameIdResponse(w http.ResponseWriter) error
}

type GetGamesGameId200JSONResponse struct {
	Game Game `json:"game"`
}

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

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

type GetGamesGameId403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetGamesGameId403JSONResponse) VisitGetGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

type GetGamesGameId404JSONResponse struct {
	Message string `json:"message"`
}

func (response GetGamesGameId404JSONResponse) VisitGetGamesGameIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(404)

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

type PostLoginRequestObject struct {
	Body *PostLoginJSONRequestBody
}

type PostLoginResponseObject interface {
	VisitPostLoginResponse(w http.ResponseWriter) error
}

type PostLogin200JSONResponse struct {
	Token string `json:"token"`
}

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

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

type PostLogin401JSONResponse struct {
	Message string `json:"message"`
}

func (response PostLogin401JSONResponse) VisitPostLoginResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(401)

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

type GetTokenRequestObject struct {
	Params GetTokenParams
}

type GetTokenResponseObject interface {
	VisitGetTokenResponse(w http.ResponseWriter) error
}

type GetToken200JSONResponse struct {
	Token string `json:"token"`
}

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

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

type GetToken403JSONResponse struct {
	Message string `json:"message"`
}

func (response GetToken403JSONResponse) VisitGetTokenResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(403)

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

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// List games
	// (GET /admin/games)
	GetAdminGames(ctx context.Context, request GetAdminGamesRequestObject) (GetAdminGamesResponseObject, error)
	// Get a game
	// (GET /admin/games/{game_id})
	GetAdminGamesGameId(ctx context.Context, request GetAdminGamesGameIdRequestObject) (GetAdminGamesGameIdResponseObject, error)
	// Update a game
	// (PUT /admin/games/{game_id})
	PutAdminGamesGameId(ctx context.Context, request PutAdminGamesGameIdRequestObject) (PutAdminGamesGameIdResponseObject, error)
	// List all users
	// (GET /admin/users)
	GetAdminUsers(ctx context.Context, request GetAdminUsersRequestObject) (GetAdminUsersResponseObject, error)
	// List games
	// (GET /games)
	GetGames(ctx context.Context, request GetGamesRequestObject) (GetGamesResponseObject, error)
	// Get a game
	// (GET /games/{game_id})
	GetGamesGameId(ctx context.Context, request GetGamesGameIdRequestObject) (GetGamesGameIdResponseObject, error)
	// User login
	// (POST /login)
	PostLogin(ctx context.Context, request PostLoginRequestObject) (PostLoginResponseObject, error)
	// Get a short-lived access token
	// (GET /token)
	GetToken(ctx context.Context, request GetTokenRequestObject) (GetTokenResponseObject, 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
}

// GetAdminGames operation middleware
func (sh *strictHandler) GetAdminGames(ctx echo.Context, params GetAdminGamesParams) error {
	var request GetAdminGamesRequestObject

	request.Params = params

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

	response, err := handler(ctx, request)

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

// GetAdminGamesGameId operation middleware
func (sh *strictHandler) GetAdminGamesGameId(ctx echo.Context, gameId int, params GetAdminGamesGameIdParams) error {
	var request GetAdminGamesGameIdRequestObject

	request.GameId = gameId
	request.Params = params

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

	response, err := handler(ctx, request)

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

// PutAdminGamesGameId operation middleware
func (sh *strictHandler) PutAdminGamesGameId(ctx echo.Context, gameId int, params PutAdminGamesGameIdParams) error {
	var request PutAdminGamesGameIdRequestObject

	request.GameId = gameId
	request.Params = params

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

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

	response, err := handler(ctx, request)

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

// GetAdminUsers operation middleware
func (sh *strictHandler) GetAdminUsers(ctx echo.Context, params GetAdminUsersParams) error {
	var request GetAdminUsersRequestObject

	request.Params = params

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

	response, err := handler(ctx, request)

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

// GetGames operation middleware
func (sh *strictHandler) GetGames(ctx echo.Context, params GetGamesParams) error {
	var request GetGamesRequestObject

	request.Params = params

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

	response, err := handler(ctx, request)

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

// GetGamesGameId operation middleware
func (sh *strictHandler) GetGamesGameId(ctx echo.Context, gameId int, params GetGamesGameIdParams) error {
	var request GetGamesGameIdRequestObject

	request.GameId = gameId
	request.Params = params

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

	response, err := handler(ctx, request)

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

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

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

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

	response, err := handler(ctx, request)

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

// GetToken operation middleware
func (sh *strictHandler) GetToken(ctx echo.Context, params GetTokenParams) error {
	var request GetTokenRequestObject

	request.Params = params

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

	response, err := handler(ctx, request)

	if err != nil {
		return err
	} else if validResponse, ok := response.(GetTokenResponseObject); ok {
		return validResponse.VisitGetTokenResponse(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/+xZX2/bNhD/Kho3oBugxY4TFJ3fsqzLMnSb0bTYQxEYtHi2mVGkSlJNvELffSCpP5Yl",
	"W7Sjpk2XPqSJdXf63d3vjnf0RxSJOBEcuFZo/BGpaAkxtr9e4BjM/4kUCUhNwX5KqEoYXk15/hTucJww",
	"QGMrHxyjEOlVYv5WWlK+QFmISCqxpoJPFUSCE1XTO3k+LFUo17AAaXQWOIYpJTXR4zbBRIoZg9gIfidh",
	"jsbo20Hl0yB3aDDJxbIQKY2lBjLFumb9p9Pnz1+cvhi2wlEaa+cvT2M0fociJhQQFKJbTDXliylwLU2M",
	"qk/se5BBCAmWgPI3m6BY/9wvc8qpWgJB1+FaMEvzG8HMQiThfUolEIOiiFIBMKznpyX016VJMbuBSBvn",
	"TOYmDK9A/gFK4YV1VHD4a47G73aHtaF6NTpHWbin0vnoCmXXbUjMk8PBnI+uXnItVwcheg2YHKZ5Lghs",
	"98c+bdYV1riLw9usTfCKCUxMKl1uTVVzpdEYJVZ8HI3UODLv7SKUfRo6NF5U2YDQ8CvKva2onUjK9ffP",
	"fgPGRBjcCsnIN89+6ERmDflCcllvgNkRHbAaXuHxBeEItA8IaTX6A2GK8V6lPMlb195VcDU6v7Lt7xDN",
	"l3cQvQaVMr2liuoy/dRSzWZ3RalRNIY7iKTD0HtdtcJpeKoiIevldWzOL54yhmfmTy1T2HaepWr9QFNp",
	"FIFS9WOo+LDLvdxcmAPy9bCgV28ZzA36pa86l/vP3QaQhoP7Ti0bkAp1XziuFnsLszXnF+RiCOo/xDUQ",
	"zcowT/cY8ZqEdurb0PyNdbQ8cGCq69qJ6brV7N79u6Hu34Qbqm6KOUSzrX+3mz+Yka3mdjDy1slbSvY2",
	"CO0E0eMkFOYF5bEPbfaJUi/cPUDtymF/SfI6YNdT1fMJ6wGo2al9Qx9+vtPYWCAgZZ1eW+REWm+KqMa/",
	"zjivU2rj2C/Nl3i8E3HPA6rdnifJ+juidsN40DNqUg0YGyEFFUmaaCp4nQZvllQFVAU4KKaLtkbkHnmV",
	"g6aabXS8HFXbNVH7hON45iyFNextTr9VIPe5svpdLHnwi4A2T2kk+DTBellXGdAYL0ANbsSSH90ki1ZV",
	"NcUkpvX4zjFTVfHPhGCAuZFOVUt7GZ20RdSINr0wUDrjWbxlzUjjsqjE3YytMUf5XNgF1uUVnbEZ1lIo",
	"FRiIkmMW3MIsOJtcohB9AKksxdDw6PhoaNCLBDhOKBqjk6Ph0RCFyITXpmhg3ztY4NilbAG2KEwW7fXV",
	"JUFjdAH6zIhdWCmjLXEMGqSys5GJN1oCJiBRiFyY0Fmql0LSf60VtB4S14tdE6nW8ip810ZYJYIrB2k0",
	"HOYNRAO36HCSMBpZy4Mb5cqpslfnYOkZ1RArn5ZWdS2EpcSr1rs/tSVVtSJHr6jSgZgHTiML0enw5B6+",
	"xNXMW5HwVyFnlBDgQZm0Tk4Whnx8KO1bKyqNYyxXhW+5Y1lYI9LgY349mvlRyvy4JFuIZTtBSavq3rWT",
	"UGvd+xFw1I+ZLUz0SuKZzdTjZ6DBf9o3/j+FDuYi5aRX1JXVet1cgA5wmY4kbSmOSfr4i+N9Ckr/LNw9",
	"7IHZeqivvLbPVl4bRMd3Wn5byBfyHVcLreuJzxqd77Qx3KIrty/NU8ZWQZoQrIG44h32XbyX/ANmlAQ5",
	"43ot4U3bT+3z87fPt5ZNZQetJg8zXXePsG+t1OMaYUvPvEZYu4p1jbDO5D4jrNP4CkdYzFjhnCFT5ya0",
	"awl6n4L9LjMnUO3G5nGPp08r1AOsUHssT09709Pe9P/dm0yxMLFwF32JUG07lFD6lRXpaxtJsFK3QpKN",
	"r5LyT49HJ23ryD0vDvP7wfLV1wdN6PepMS3+gY376jvz72jtZ/cVvjXik/3a5oBTvQSuDdRifzj+VPtD",
	"JIGYd2GmPskOUWQzEDIo07kx2iqQgaO1ZXgZ+m2HwBsr8LiG2S+MT1/NLOHao1oKqX9k9AOQAFvPAxer",
	"LMuy/wIAAP//vgYmOHMsAAA=",
}

// 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
}