server.gen.go

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

import (
	"context"
	"fmt"
	"io"
	"net/url"

	"github.com/gofiber/fiber/v2"
	"github.com/oapi-codegen/runtime"
)

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// List all accounts
	// (GET /accounts)
	ListAccounts(c *fiber.Ctx, params ListAccountsParams) error
	// Creates a new account
	// (POST /accounts)
	CreateAccount(c *fiber.Ctx) error
	// Deletes an account by ID
	// (DELETE /accounts/{accountId})
	DeleteAccount(c *fiber.Ctx, accountId AccountId) error
	// Gets an account by ID
	// (GET /accounts/{accountId})
	GetAccount(c *fiber.Ctx, accountId AccountId) error
	// Updates an account by ID
	// (PUT /accounts/{accountId})
	UpdateAccount(c *fiber.Ctx, accountId AccountId) error
	// Deletes a signing key group by ID
	// (DELETE /accounts/{accountId}/groups)
	DeleteAccountSigningKeyGroup(c *fiber.Ctx, accountId AccountId) error
	// List all signing key groups for an account
	// (GET /accounts/{accountId}/groups)
	ListAccountSigningKeyGroups(c *fiber.Ctx, accountId AccountId, params ListAccountSigningKeyGroupsParams) error
	// Creates a new signing key group
	// (POST /accounts/{accountId}/groups)
	CreateAccountSigningKeyGroup(c *fiber.Ctx, accountId AccountId) error
	// Gets a token for an account
	// (GET /accounts/{accountId}/token)
	GetAccountToken(c *fiber.Ctx, accountId AccountId) error
	// List all operators
	// (GET /operators)
	ListOperators(c *fiber.Ctx, params ListOperatorsParams) error
	// Creates a new operator
	// (POST /operators)
	CreateOperator(c *fiber.Ctx) error
	// Deletes an operator by ID
	// (DELETE /operators/{operatorId})
	DeleteOperator(c *fiber.Ctx, operatorId OperatorId) error
	// Gets an operator by ID
	// (GET /operators/{operatorId})
	GetOperator(c *fiber.Ctx, operatorId OperatorId) error
	// Updates an operator by ID
	// (PUT /operators/{operatorId})
	UpdateOperator(c *fiber.Ctx, operatorId OperatorId) error
	// List all signing key groups for an operator
	// (GET /operators/{operatorId}/groups)
	ListOperatorSigningKeyGroups(c *fiber.Ctx, operatorId OperatorId, params ListOperatorSigningKeyGroupsParams) error
	// Creates a new signing key group
	// (POST /operators/{operatorId}/groups)
	CreateOperatorSigningKeyGroup(c *fiber.Ctx, operatorId OperatorId) error
	// Gets the system account for an operator
	// (GET /operators/{operatorId}/system-account)
	GetOperatorSystemAccount(c *fiber.Ctx, operatorId OperatorId) error
	// Updates the system account for an operator
	// (PUT /operators/{operatorId}/system-account)
	UpdateOperatorSystemAccount(c *fiber.Ctx, operatorId OperatorId) error
	// Gets a token for an operator
	// (GET /operators/{operatorId}/token)
	GetOperatorToken(c *fiber.Ctx, operatorId OperatorId) error
	// List all managed systems.
	// (GET /systems)
	ListSystems(c *fiber.Ctx, params ListSystemsParams) error
	// Creates a new system
	// (POST /systems)
	CreateSystem(c *fiber.Ctx) error
	// Deletes a system by ID
	// (DELETE /systems/{systemId})
	DeleteSystem(c *fiber.Ctx, systemId SystemId) error
	// Gets a system by ID
	// (GET /systems/{systemId})
	GetSystem(c *fiber.Ctx, systemId SystemId) error
	// Updates a system by ID
	// (PUT /systems/{systemId})
	UpdateSystem(c *fiber.Ctx, systemId SystemId) error
	// Deletes the operator for a system
	// (DELETE /systems/{systemId}/operator)
	DeleteSystemOperator(c *fiber.Ctx, systemId SystemId) error
	// Gets the operator for a system
	// (GET /systems/{systemId}/operator)
	GetSystemOperator(c *fiber.Ctx, systemId SystemId) error
	// Updates the operator for a system
	// (PUT /systems/{systemId}/operator)
	UpdateSystemOperator(c *fiber.Ctx, systemId SystemId) error
	// List all teams
	// (GET /teams)
	ListTeams(c *fiber.Ctx, params ListTeamsParams) error
	// Creates a new team
	// (POST /teams)
	CreateTeam(c *fiber.Ctx) error
	// Deletes a team by ID
	// (DELETE /teams/{teamId})
	DeleteTeam(c *fiber.Ctx, teamId TeamId) error
	// Gets a team by ID
	// (GET /teams/{teamId})
	GetTeam(c *fiber.Ctx, teamId TeamId) error
	// List all accounts for a team
	// (GET /teams/{teamId}/accounts)
	ListTeamAccounts(c *fiber.Ctx, teamId TeamId, params ListTeamAccountsParams) error
	// List all systems for a team
	// (GET /teams/{teamId}/systems)
	ListTeamSystems(c *fiber.Ctx, teamId TeamId, params ListTeamSystemsParams) error
	// List all users
	// (GET /users)
	ListUsers(c *fiber.Ctx, params ListUsersParams) error
	// Creates a new user
	// (POST /users)
	CreateUser(c *fiber.Ctx) error
	// Deletes a user by ID
	// (DELETE /users/{userId})
	DeleteUser(c *fiber.Ctx, userId UserId) error
	// Gets a user by ID
	// (GET /users/{userId})
	GetUser(c *fiber.Ctx, userId UserId) error
	// Updates a user by ID
	// (PUT /users/{userId})
	UpdateUser(c *fiber.Ctx, userId UserId) error
	// Gets the credentials for a user
	// (GET /users/{userId}/credentials)
	GetUserCredentials(c *fiber.Ctx, userId UserId) error
	// Gets a token for a user
	// (GET /users/{userId}/token)
	GetUserToken(c *fiber.Ctx, userId UserId) error
	// Returns the current version of the API.
	// (GET /version)
	Version(c *fiber.Ctx) error
}

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

type MiddlewareFunc fiber.Handler

// ListAccounts operation middleware
func (siw *ServerInterfaceWrapper) ListAccounts(c *fiber.Ctx) error {

	var err error

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListAccounts(c, params)
}

// CreateAccount operation middleware
func (siw *ServerInterfaceWrapper) CreateAccount(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateAccount(c)
}

// DeleteAccount operation middleware
func (siw *ServerInterfaceWrapper) DeleteAccount(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteAccount(c, accountId)
}

// GetAccount operation middleware
func (siw *ServerInterfaceWrapper) GetAccount(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetAccount(c, accountId)
}

// UpdateAccount operation middleware
func (siw *ServerInterfaceWrapper) UpdateAccount(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateAccount(c, accountId)
}

// DeleteAccountSigningKeyGroup operation middleware
func (siw *ServerInterfaceWrapper) DeleteAccountSigningKeyGroup(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteAccountSigningKeyGroup(c, accountId)
}

// ListAccountSigningKeyGroups operation middleware
func (siw *ServerInterfaceWrapper) ListAccountSigningKeyGroups(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{"read:groups"})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListAccountSigningKeyGroups(c, accountId, params)
}

// CreateAccountSigningKeyGroup operation middleware
func (siw *ServerInterfaceWrapper) CreateAccountSigningKeyGroup(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateAccountSigningKeyGroup(c, accountId)
}

// GetAccountToken operation middleware
func (siw *ServerInterfaceWrapper) GetAccountToken(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "accountId" -------------
	var accountId AccountId

	err = runtime.BindStyledParameterWithOptions("simple", "accountId", c.Params("accountId"), &accountId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter accountId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetAccountToken(c, accountId)
}

// ListOperators operation middleware
func (siw *ServerInterfaceWrapper) ListOperators(c *fiber.Ctx) error {

	var err error

	c.Context().SetUserValue(BearerAuthScopes, []string{"read:operators"})

	c.Context().SetUserValue(ApiKeyScopes, []string{"superadmin"})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListOperators(c, params)
}

// CreateOperator operation middleware
func (siw *ServerInterfaceWrapper) CreateOperator(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateOperator(c)
}

// DeleteOperator operation middleware
func (siw *ServerInterfaceWrapper) DeleteOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteOperator(c, operatorId)
}

// GetOperator operation middleware
func (siw *ServerInterfaceWrapper) GetOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetOperator(c, operatorId)
}

// UpdateOperator operation middleware
func (siw *ServerInterfaceWrapper) UpdateOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateOperator(c, operatorId)
}

// ListOperatorSigningKeyGroups operation middleware
func (siw *ServerInterfaceWrapper) ListOperatorSigningKeyGroups(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListOperatorSigningKeyGroups(c, operatorId, params)
}

// CreateOperatorSigningKeyGroup operation middleware
func (siw *ServerInterfaceWrapper) CreateOperatorSigningKeyGroup(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateOperatorSigningKeyGroup(c, operatorId)
}

// GetOperatorSystemAccount operation middleware
func (siw *ServerInterfaceWrapper) GetOperatorSystemAccount(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetOperatorSystemAccount(c, operatorId)
}

// UpdateOperatorSystemAccount operation middleware
func (siw *ServerInterfaceWrapper) UpdateOperatorSystemAccount(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateOperatorSystemAccount(c, operatorId)
}

// GetOperatorToken operation middleware
func (siw *ServerInterfaceWrapper) GetOperatorToken(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "operatorId" -------------
	var operatorId OperatorId

	err = runtime.BindStyledParameterWithOptions("simple", "operatorId", c.Params("operatorId"), &operatorId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter operatorId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetOperatorToken(c, operatorId)
}

// ListSystems operation middleware
func (siw *ServerInterfaceWrapper) ListSystems(c *fiber.Ctx) error {

	var err error

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListSystems(c, params)
}

// CreateSystem operation middleware
func (siw *ServerInterfaceWrapper) CreateSystem(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateSystem(c)
}

// DeleteSystem operation middleware
func (siw *ServerInterfaceWrapper) DeleteSystem(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteSystem(c, systemId)
}

// GetSystem operation middleware
func (siw *ServerInterfaceWrapper) GetSystem(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetSystem(c, systemId)
}

// UpdateSystem operation middleware
func (siw *ServerInterfaceWrapper) UpdateSystem(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateSystem(c, systemId)
}

// DeleteSystemOperator operation middleware
func (siw *ServerInterfaceWrapper) DeleteSystemOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteSystemOperator(c, systemId)
}

// GetSystemOperator operation middleware
func (siw *ServerInterfaceWrapper) GetSystemOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetSystemOperator(c, systemId)
}

// UpdateSystemOperator operation middleware
func (siw *ServerInterfaceWrapper) UpdateSystemOperator(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "systemId" -------------
	var systemId SystemId

	err = runtime.BindStyledParameterWithOptions("simple", "systemId", c.Params("systemId"), &systemId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter systemId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateSystemOperator(c, systemId)
}

// ListTeams operation middleware
func (siw *ServerInterfaceWrapper) ListTeams(c *fiber.Ctx) error {

	var err error

	c.Context().SetUserValue(BearerAuthScopes, []string{"read:teams"})

	c.Context().SetUserValue(ApiKeyScopes, []string{"superadmin"})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListTeams(c, params)
}

// CreateTeam operation middleware
func (siw *ServerInterfaceWrapper) CreateTeam(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateTeam(c)
}

// DeleteTeam operation middleware
func (siw *ServerInterfaceWrapper) DeleteTeam(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "teamId" -------------
	var teamId TeamId

	err = runtime.BindStyledParameterWithOptions("simple", "teamId", c.Params("teamId"), &teamId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter teamId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{"delete"})

	c.Context().SetUserValue(ApiKeyScopes, []string{"delete"})

	return siw.Handler.DeleteTeam(c, teamId)
}

// GetTeam operation middleware
func (siw *ServerInterfaceWrapper) GetTeam(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "teamId" -------------
	var teamId TeamId

	err = runtime.BindStyledParameterWithOptions("simple", "teamId", c.Params("teamId"), &teamId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter teamId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{"superadmin"})

	c.Context().SetUserValue(ApiKeyScopes, []string{"superadmin"})

	return siw.Handler.GetTeam(c, teamId)
}

// ListTeamAccounts operation middleware
func (siw *ServerInterfaceWrapper) ListTeamAccounts(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "teamId" -------------
	var teamId TeamId

	err = runtime.BindStyledParameterWithOptions("simple", "teamId", c.Params("teamId"), &teamId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter teamId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{"read:accounts"})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListTeamAccounts(c, teamId, params)
}

// ListTeamSystems operation middleware
func (siw *ServerInterfaceWrapper) ListTeamSystems(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "teamId" -------------
	var teamId TeamId

	err = runtime.BindStyledParameterWithOptions("simple", "teamId", c.Params("teamId"), &teamId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter teamId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{"read:systems"})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListTeamSystems(c, teamId, params)
}

// ListUsers operation middleware
func (siw *ServerInterfaceWrapper) ListUsers(c *fiber.Ctx) error {

	var err error

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

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

	var query url.Values
	query, err = url.ParseQuery(string(c.Request().URI().QueryString()))
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for query string: %w", err).Error())
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", query, &params.Offset)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter offset: %w", err).Error())
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", query, &params.Limit)
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter limit: %w", err).Error())
	}

	return siw.Handler.ListUsers(c, params)
}

// CreateUser operation middleware
func (siw *ServerInterfaceWrapper) CreateUser(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.CreateUser(c)
}

// DeleteUser operation middleware
func (siw *ServerInterfaceWrapper) DeleteUser(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "userId" -------------
	var userId UserId

	err = runtime.BindStyledParameterWithOptions("simple", "userId", c.Params("userId"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter userId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.DeleteUser(c, userId)
}

// GetUser operation middleware
func (siw *ServerInterfaceWrapper) GetUser(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "userId" -------------
	var userId UserId

	err = runtime.BindStyledParameterWithOptions("simple", "userId", c.Params("userId"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter userId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetUser(c, userId)
}

// UpdateUser operation middleware
func (siw *ServerInterfaceWrapper) UpdateUser(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "userId" -------------
	var userId UserId

	err = runtime.BindStyledParameterWithOptions("simple", "userId", c.Params("userId"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter userId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.UpdateUser(c, userId)
}

// GetUserCredentials operation middleware
func (siw *ServerInterfaceWrapper) GetUserCredentials(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "userId" -------------
	var userId UserId

	err = runtime.BindStyledParameterWithOptions("simple", "userId", c.Params("userId"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter userId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetUserCredentials(c, userId)
}

// GetUserToken operation middleware
func (siw *ServerInterfaceWrapper) GetUserToken(c *fiber.Ctx) error {

	var err error

	// ------------- Path parameter "userId" -------------
	var userId UserId

	err = runtime.BindStyledParameterWithOptions("simple", "userId", c.Params("userId"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, fmt.Errorf("Invalid format for parameter userId: %w", err).Error())
	}

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.GetUserToken(c, userId)
}

// Version operation middleware
func (siw *ServerInterfaceWrapper) Version(c *fiber.Ctx) error {

	c.Context().SetUserValue(BearerAuthScopes, []string{})

	c.Context().SetUserValue(ApiKeyScopes, []string{})

	return siw.Handler.Version(c)
}

// FiberServerOptions provides options for the Fiber server.
type FiberServerOptions struct {
	BaseURL     string
	Middlewares []MiddlewareFunc
}

// RegisterHandlers creates http.Handler with routing matching OpenAPI spec.
func RegisterHandlers(router fiber.Router, si ServerInterface) {
	RegisterHandlersWithOptions(router, si, FiberServerOptions{})
}

// RegisterHandlersWithOptions creates http.Handler with additional options
func RegisterHandlersWithOptions(router fiber.Router, si ServerInterface, options FiberServerOptions) {
	wrapper := ServerInterfaceWrapper{
		Handler: si,
	}

	for _, m := range options.Middlewares {
		router.Use(m)
	}

	router.Get(options.BaseURL+"/accounts", wrapper.ListAccounts)

	router.Post(options.BaseURL+"/accounts", wrapper.CreateAccount)

	router.Delete(options.BaseURL+"/accounts/:accountId", wrapper.DeleteAccount)

	router.Get(options.BaseURL+"/accounts/:accountId", wrapper.GetAccount)

	router.Put(options.BaseURL+"/accounts/:accountId", wrapper.UpdateAccount)

	router.Delete(options.BaseURL+"/accounts/:accountId/groups", wrapper.DeleteAccountSigningKeyGroup)

	router.Get(options.BaseURL+"/accounts/:accountId/groups", wrapper.ListAccountSigningKeyGroups)

	router.Post(options.BaseURL+"/accounts/:accountId/groups", wrapper.CreateAccountSigningKeyGroup)

	router.Get(options.BaseURL+"/accounts/:accountId/token", wrapper.GetAccountToken)

	router.Get(options.BaseURL+"/operators", wrapper.ListOperators)

	router.Post(options.BaseURL+"/operators", wrapper.CreateOperator)

	router.Delete(options.BaseURL+"/operators/:operatorId", wrapper.DeleteOperator)

	router.Get(options.BaseURL+"/operators/:operatorId", wrapper.GetOperator)

	router.Put(options.BaseURL+"/operators/:operatorId", wrapper.UpdateOperator)

	router.Get(options.BaseURL+"/operators/:operatorId/groups", wrapper.ListOperatorSigningKeyGroups)

	router.Post(options.BaseURL+"/operators/:operatorId/groups", wrapper.CreateOperatorSigningKeyGroup)

	router.Get(options.BaseURL+"/operators/:operatorId/system-account", wrapper.GetOperatorSystemAccount)

	router.Put(options.BaseURL+"/operators/:operatorId/system-account", wrapper.UpdateOperatorSystemAccount)

	router.Get(options.BaseURL+"/operators/:operatorId/token", wrapper.GetOperatorToken)

	router.Get(options.BaseURL+"/systems", wrapper.ListSystems)

	router.Post(options.BaseURL+"/systems", wrapper.CreateSystem)

	router.Delete(options.BaseURL+"/systems/:systemId", wrapper.DeleteSystem)

	router.Get(options.BaseURL+"/systems/:systemId", wrapper.GetSystem)

	router.Put(options.BaseURL+"/systems/:systemId", wrapper.UpdateSystem)

	router.Delete(options.BaseURL+"/systems/:systemId/operator", wrapper.DeleteSystemOperator)

	router.Get(options.BaseURL+"/systems/:systemId/operator", wrapper.GetSystemOperator)

	router.Put(options.BaseURL+"/systems/:systemId/operator", wrapper.UpdateSystemOperator)

	router.Get(options.BaseURL+"/teams", wrapper.ListTeams)

	router.Post(options.BaseURL+"/teams", wrapper.CreateTeam)

	router.Delete(options.BaseURL+"/teams/:teamId", wrapper.DeleteTeam)

	router.Get(options.BaseURL+"/teams/:teamId", wrapper.GetTeam)

	router.Get(options.BaseURL+"/teams/:teamId/accounts", wrapper.ListTeamAccounts)

	router.Get(options.BaseURL+"/teams/:teamId/systems", wrapper.ListTeamSystems)

	router.Get(options.BaseURL+"/users", wrapper.ListUsers)

	router.Post(options.BaseURL+"/users", wrapper.CreateUser)

	router.Delete(options.BaseURL+"/users/:userId", wrapper.DeleteUser)

	router.Get(options.BaseURL+"/users/:userId", wrapper.GetUser)

	router.Put(options.BaseURL+"/users/:userId", wrapper.UpdateUser)

	router.Get(options.BaseURL+"/users/:userId/credentials", wrapper.GetUserCredentials)

	router.Get(options.BaseURL+"/users/:userId/token", wrapper.GetUserToken)

	router.Get(options.BaseURL+"/version", wrapper.Version)

}

type BadRequestJSONResponse Error

type DuplicateJSONResponse Error

type InternalErrorJSONResponse Error

type NotFoundJSONResponse Error

type UnauthorizedJSONResponse Error

type UnimplementedJSONResponse Error

type ListAccountsRequestObject struct {
	Params ListAccountsParams
	Body   *ListAccountsJSONRequestBody
}

type ListAccountsResponseObject interface {
	VisitListAccountsResponse(ctx *fiber.Ctx) error
}

type ListAccounts200JSONResponse struct {
	Limit   *int       `json:"limit,omitempty"`
	Offset  *int       `json:"offset,omitempty"`
	Results *[]Account `json:"results,omitempty"`
	Total   *int       `json:"total,omitempty"`
}

func (response ListAccounts200JSONResponse) VisitListAccountsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListAccountsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListAccountsdefaultJSONResponse) VisitListAccountsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateAccountRequestObject struct {
	Body *CreateAccountJSONRequestBody
}

type CreateAccountResponseObject interface {
	VisitCreateAccountResponse(ctx *fiber.Ctx) error
}

type CreateAccount201JSONResponse Account

func (response CreateAccount201JSONResponse) VisitCreateAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateAccountdefaultJSONResponse) VisitCreateAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteAccountRequestObject struct {
	AccountId AccountId `json:"accountId"`
}

type DeleteAccountResponseObject interface {
	VisitDeleteAccountResponse(ctx *fiber.Ctx) error
}

type DeleteAccount204Response struct {
}

func (response DeleteAccount204Response) VisitDeleteAccountResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteAccountdefaultJSONResponse) VisitDeleteAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetAccountRequestObject struct {
	AccountId AccountId `json:"accountId"`
}

type GetAccountResponseObject interface {
	VisitGetAccountResponse(ctx *fiber.Ctx) error
}

type GetAccount200JSONResponse Account

func (response GetAccount200JSONResponse) VisitGetAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetAccountdefaultJSONResponse) VisitGetAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateAccountRequestObject struct {
	AccountId AccountId `json:"accountId"`
	Body      *UpdateAccountJSONRequestBody
}

type UpdateAccountResponseObject interface {
	VisitUpdateAccountResponse(ctx *fiber.Ctx) error
}

type UpdateAccount200JSONResponse Account

func (response UpdateAccount200JSONResponse) VisitUpdateAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type UpdateAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateAccountdefaultJSONResponse) VisitUpdateAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteAccountSigningKeyGroupRequestObject struct {
	AccountId AccountId `json:"accountId"`
}

type DeleteAccountSigningKeyGroupResponseObject interface {
	VisitDeleteAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error
}

type DeleteAccountSigningKeyGroup204Response struct {
}

func (response DeleteAccountSigningKeyGroup204Response) VisitDeleteAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteAccountSigningKeyGroupdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteAccountSigningKeyGroupdefaultJSONResponse) VisitDeleteAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListAccountSigningKeyGroupsRequestObject struct {
	AccountId AccountId `json:"accountId"`
	Params    ListAccountSigningKeyGroupsParams
}

type ListAccountSigningKeyGroupsResponseObject interface {
	VisitListAccountSigningKeyGroupsResponse(ctx *fiber.Ctx) error
}

type ListAccountSigningKeyGroups200JSONResponse struct {
	Limit   *int               `json:"limit,omitempty"`
	Offset  *int               `json:"offset,omitempty"`
	Results *[]SigningKeyGroup `json:"results,omitempty"`
	Total   *int               `json:"total,omitempty"`
}

func (response ListAccountSigningKeyGroups200JSONResponse) VisitListAccountSigningKeyGroupsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListAccountSigningKeyGroupsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListAccountSigningKeyGroupsdefaultJSONResponse) VisitListAccountSigningKeyGroupsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateAccountSigningKeyGroupRequestObject struct {
	AccountId AccountId `json:"accountId"`
	Body      *CreateAccountSigningKeyGroupJSONRequestBody
}

type CreateAccountSigningKeyGroupResponseObject interface {
	VisitCreateAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error
}

type CreateAccountSigningKeyGroup201JSONResponse SigningKeyGroup

func (response CreateAccountSigningKeyGroup201JSONResponse) VisitCreateAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateAccountSigningKeyGroupdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateAccountSigningKeyGroupdefaultJSONResponse) VisitCreateAccountSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetAccountTokenRequestObject struct {
	AccountId AccountId `json:"accountId"`
}

type GetAccountTokenResponseObject interface {
	VisitGetAccountTokenResponse(ctx *fiber.Ctx) error
}

type GetAccountToken200JSONResponse JWTToken

func (response GetAccountToken200JSONResponse) VisitGetAccountTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetAccountTokendefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetAccountTokendefaultJSONResponse) VisitGetAccountTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListOperatorsRequestObject struct {
	Params ListOperatorsParams
}

type ListOperatorsResponseObject interface {
	VisitListOperatorsResponse(ctx *fiber.Ctx) error
}

type ListOperators200JSONResponse struct {
	Limit   *int        `json:"limit,omitempty"`
	Offset  *int        `json:"offset,omitempty"`
	Results *[]Operator `json:"results,omitempty"`
	Total   *int        `json:"total,omitempty"`
}

func (response ListOperators200JSONResponse) VisitListOperatorsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListOperatorsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListOperatorsdefaultJSONResponse) VisitListOperatorsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateOperatorRequestObject struct {
	Body *CreateOperatorJSONRequestBody
}

type CreateOperatorResponseObject interface {
	VisitCreateOperatorResponse(ctx *fiber.Ctx) error
}

type CreateOperator201JSONResponse Operator

func (response CreateOperator201JSONResponse) VisitCreateOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateOperatordefaultJSONResponse) VisitCreateOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteOperatorRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
}

type DeleteOperatorResponseObject interface {
	VisitDeleteOperatorResponse(ctx *fiber.Ctx) error
}

type DeleteOperator204Response struct {
}

func (response DeleteOperator204Response) VisitDeleteOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteOperatordefaultJSONResponse) VisitDeleteOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetOperatorRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
}

type GetOperatorResponseObject interface {
	VisitGetOperatorResponse(ctx *fiber.Ctx) error
}

type GetOperator200JSONResponse Operator

func (response GetOperator200JSONResponse) VisitGetOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetOperatordefaultJSONResponse) VisitGetOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateOperatorRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
	Body       *UpdateOperatorJSONRequestBody
}

type UpdateOperatorResponseObject interface {
	VisitUpdateOperatorResponse(ctx *fiber.Ctx) error
}

type UpdateOperator200JSONResponse Operator

func (response UpdateOperator200JSONResponse) VisitUpdateOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type UpdateOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateOperatordefaultJSONResponse) VisitUpdateOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListOperatorSigningKeyGroupsRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
	Params     ListOperatorSigningKeyGroupsParams
}

type ListOperatorSigningKeyGroupsResponseObject interface {
	VisitListOperatorSigningKeyGroupsResponse(ctx *fiber.Ctx) error
}

type ListOperatorSigningKeyGroups200JSONResponse struct {
	Limit   *int               `json:"limit,omitempty"`
	Offset  *int               `json:"offset,omitempty"`
	Results *[]SigningKeyGroup `json:"results,omitempty"`
	Total   *int               `json:"total,omitempty"`
}

func (response ListOperatorSigningKeyGroups200JSONResponse) VisitListOperatorSigningKeyGroupsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListOperatorSigningKeyGroupsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListOperatorSigningKeyGroupsdefaultJSONResponse) VisitListOperatorSigningKeyGroupsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateOperatorSigningKeyGroupRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
	Body       *CreateOperatorSigningKeyGroupJSONRequestBody
}

type CreateOperatorSigningKeyGroupResponseObject interface {
	VisitCreateOperatorSigningKeyGroupResponse(ctx *fiber.Ctx) error
}

type CreateOperatorSigningKeyGroup201JSONResponse SigningKeyGroup

func (response CreateOperatorSigningKeyGroup201JSONResponse) VisitCreateOperatorSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateOperatorSigningKeyGroupdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateOperatorSigningKeyGroupdefaultJSONResponse) VisitCreateOperatorSigningKeyGroupResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetOperatorSystemAccountRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
}

type GetOperatorSystemAccountResponseObject interface {
	VisitGetOperatorSystemAccountResponse(ctx *fiber.Ctx) error
}

type GetOperatorSystemAccount200JSONResponse Account

func (response GetOperatorSystemAccount200JSONResponse) VisitGetOperatorSystemAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetOperatorSystemAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetOperatorSystemAccountdefaultJSONResponse) VisitGetOperatorSystemAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateOperatorSystemAccountRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
	Body       *UpdateOperatorSystemAccountJSONRequestBody
}

type UpdateOperatorSystemAccountResponseObject interface {
	VisitUpdateOperatorSystemAccountResponse(ctx *fiber.Ctx) error
}

type UpdateOperatorSystemAccount201JSONResponse Account

func (response UpdateOperatorSystemAccount201JSONResponse) VisitUpdateOperatorSystemAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type UpdateOperatorSystemAccountdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateOperatorSystemAccountdefaultJSONResponse) VisitUpdateOperatorSystemAccountResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetOperatorTokenRequestObject struct {
	OperatorId OperatorId `json:"operatorId"`
}

type GetOperatorTokenResponseObject interface {
	VisitGetOperatorTokenResponse(ctx *fiber.Ctx) error
}

type GetOperatorToken200JSONResponse JWTToken

func (response GetOperatorToken200JSONResponse) VisitGetOperatorTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetOperatorTokendefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetOperatorTokendefaultJSONResponse) VisitGetOperatorTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListSystemsRequestObject struct {
	Params ListSystemsParams
}

type ListSystemsResponseObject interface {
	VisitListSystemsResponse(ctx *fiber.Ctx) error
}

type ListSystems200JSONResponse struct {
	Limit   *int      `json:"limit,omitempty"`
	Offset  *int      `json:"offset,omitempty"`
	Results *[]System `json:"results,omitempty"`
	Total   *int      `json:"total,omitempty"`
}

func (response ListSystems200JSONResponse) VisitListSystemsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListSystemsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListSystemsdefaultJSONResponse) VisitListSystemsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateSystemRequestObject struct {
	Body *CreateSystemJSONRequestBody
}

type CreateSystemResponseObject interface {
	VisitCreateSystemResponse(ctx *fiber.Ctx) error
}

type CreateSystem201JSONResponse System

func (response CreateSystem201JSONResponse) VisitCreateSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateSystemdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateSystemdefaultJSONResponse) VisitCreateSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteSystemRequestObject struct {
	SystemId SystemId `json:"systemId"`
}

type DeleteSystemResponseObject interface {
	VisitDeleteSystemResponse(ctx *fiber.Ctx) error
}

type DeleteSystem204Response struct {
}

func (response DeleteSystem204Response) VisitDeleteSystemResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteSystemdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteSystemdefaultJSONResponse) VisitDeleteSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetSystemRequestObject struct {
	SystemId SystemId `json:"systemId"`
}

type GetSystemResponseObject interface {
	VisitGetSystemResponse(ctx *fiber.Ctx) error
}

type GetSystem200JSONResponse System

func (response GetSystem200JSONResponse) VisitGetSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetSystemdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetSystemdefaultJSONResponse) VisitGetSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateSystemRequestObject struct {
	SystemId SystemId `json:"systemId"`
	Body     *UpdateSystemJSONRequestBody
}

type UpdateSystemResponseObject interface {
	VisitUpdateSystemResponse(ctx *fiber.Ctx) error
}

type UpdateSystem200JSONResponse System

func (response UpdateSystem200JSONResponse) VisitUpdateSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type UpdateSystemdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateSystemdefaultJSONResponse) VisitUpdateSystemResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteSystemOperatorRequestObject struct {
	SystemId SystemId `json:"systemId"`
}

type DeleteSystemOperatorResponseObject interface {
	VisitDeleteSystemOperatorResponse(ctx *fiber.Ctx) error
}

type DeleteSystemOperator204Response struct {
}

func (response DeleteSystemOperator204Response) VisitDeleteSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteSystemOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteSystemOperatordefaultJSONResponse) VisitDeleteSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetSystemOperatorRequestObject struct {
	SystemId SystemId `json:"systemId"`
}

type GetSystemOperatorResponseObject interface {
	VisitGetSystemOperatorResponse(ctx *fiber.Ctx) error
}

type GetSystemOperator200JSONResponse Operator

func (response GetSystemOperator200JSONResponse) VisitGetSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetSystemOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetSystemOperatordefaultJSONResponse) VisitGetSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateSystemOperatorRequestObject struct {
	SystemId SystemId `json:"systemId"`
	Body     *UpdateSystemOperatorJSONRequestBody
}

type UpdateSystemOperatorResponseObject interface {
	VisitUpdateSystemOperatorResponse(ctx *fiber.Ctx) error
}

type UpdateSystemOperator201JSONResponse Operator

func (response UpdateSystemOperator201JSONResponse) VisitUpdateSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type UpdateSystemOperatordefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateSystemOperatordefaultJSONResponse) VisitUpdateSystemOperatorResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListTeamsRequestObject struct {
	Params ListTeamsParams
}

type ListTeamsResponseObject interface {
	VisitListTeamsResponse(ctx *fiber.Ctx) error
}

type ListTeams200JSONResponse struct {
	Limit   *int    `json:"limit,omitempty"`
	Offset  *int    `json:"offset,omitempty"`
	Results *[]Team `json:"results,omitempty"`
	Total   *int    `json:"total,omitempty"`
}

func (response ListTeams200JSONResponse) VisitListTeamsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListTeamsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListTeamsdefaultJSONResponse) VisitListTeamsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateTeamRequestObject struct {
	Body *CreateTeamJSONRequestBody
}

type CreateTeamResponseObject interface {
	VisitCreateTeamResponse(ctx *fiber.Ctx) error
}

type CreateTeam201JSONResponse Team

func (response CreateTeam201JSONResponse) VisitCreateTeamResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateTeamdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateTeamdefaultJSONResponse) VisitCreateTeamResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteTeamRequestObject struct {
	TeamId TeamId `json:"teamId"`
}

type DeleteTeamResponseObject interface {
	VisitDeleteTeamResponse(ctx *fiber.Ctx) error
}

type DeleteTeam204Response struct {
}

func (response DeleteTeam204Response) VisitDeleteTeamResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteTeamdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteTeamdefaultJSONResponse) VisitDeleteTeamResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetTeamRequestObject struct {
	TeamId TeamId `json:"teamId"`
}

type GetTeamResponseObject interface {
	VisitGetTeamResponse(ctx *fiber.Ctx) error
}

type GetTeam200JSONResponse Team

func (response GetTeam200JSONResponse) VisitGetTeamResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetTeamdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetTeamdefaultJSONResponse) VisitGetTeamResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListTeamAccountsRequestObject struct {
	TeamId TeamId `json:"teamId"`
	Params ListTeamAccountsParams
}

type ListTeamAccountsResponseObject interface {
	VisitListTeamAccountsResponse(ctx *fiber.Ctx) error
}

type ListTeamAccounts200JSONResponse struct {
	Limit   *int       `json:"limit,omitempty"`
	Offset  *int       `json:"offset,omitempty"`
	Results *[]Account `json:"results,omitempty"`
	Total   *int       `json:"total,omitempty"`
}

func (response ListTeamAccounts200JSONResponse) VisitListTeamAccountsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListTeamAccountsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListTeamAccountsdefaultJSONResponse) VisitListTeamAccountsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListTeamSystemsRequestObject struct {
	TeamId TeamId `json:"teamId"`
	Params ListTeamSystemsParams
}

type ListTeamSystemsResponseObject interface {
	VisitListTeamSystemsResponse(ctx *fiber.Ctx) error
}

type ListTeamSystems200JSONResponse struct {
	Limit   *int      `json:"limit,omitempty"`
	Offset  *int      `json:"offset,omitempty"`
	Results *[]System `json:"results,omitempty"`
	Total   *int      `json:"total,omitempty"`
}

func (response ListTeamSystems200JSONResponse) VisitListTeamSystemsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListTeamSystemsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListTeamSystemsdefaultJSONResponse) VisitListTeamSystemsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type ListUsersRequestObject struct {
	Params ListUsersParams
	Body   *ListUsersJSONRequestBody
}

type ListUsersResponseObject interface {
	VisitListUsersResponse(ctx *fiber.Ctx) error
}

type ListUsers200JSONResponse struct {
	Limit   *int    `json:"limit,omitempty"`
	Offset  *int    `json:"offset,omitempty"`
	Results *[]User `json:"results,omitempty"`
	Total   *int    `json:"total,omitempty"`
}

func (response ListUsers200JSONResponse) VisitListUsersResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type ListUsersdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response ListUsersdefaultJSONResponse) VisitListUsersResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type CreateUserRequestObject struct {
	Body *CreateUserJSONRequestBody
}

type CreateUserResponseObject interface {
	VisitCreateUserResponse(ctx *fiber.Ctx) error
}

type CreateUser201JSONResponse User

func (response CreateUser201JSONResponse) VisitCreateUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(201)

	return ctx.JSON(&response)
}

type CreateUserdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response CreateUserdefaultJSONResponse) VisitCreateUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type DeleteUserRequestObject struct {
	UserId UserId `json:"userId"`
}

type DeleteUserResponseObject interface {
	VisitDeleteUserResponse(ctx *fiber.Ctx) error
}

type DeleteUser204Response struct {
}

func (response DeleteUser204Response) VisitDeleteUserResponse(ctx *fiber.Ctx) error {
	ctx.Status(204)
	return nil
}

type DeleteUserdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response DeleteUserdefaultJSONResponse) VisitDeleteUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetUserRequestObject struct {
	UserId UserId `json:"userId"`
}

type GetUserResponseObject interface {
	VisitGetUserResponse(ctx *fiber.Ctx) error
}

type GetUser200JSONResponse User

func (response GetUser200JSONResponse) VisitGetUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetUserdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetUserdefaultJSONResponse) VisitGetUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type UpdateUserRequestObject struct {
	UserId UserId `json:"userId"`
	Body   *UpdateUserJSONRequestBody
}

type UpdateUserResponseObject interface {
	VisitUpdateUserResponse(ctx *fiber.Ctx) error
}

type UpdateUser200JSONResponse User

func (response UpdateUser200JSONResponse) VisitUpdateUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type UpdateUserdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response UpdateUserdefaultJSONResponse) VisitUpdateUserResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetUserCredentialsRequestObject struct {
	UserId UserId `json:"userId"`
}

type GetUserCredentialsResponseObject interface {
	VisitGetUserCredentialsResponse(ctx *fiber.Ctx) error
}

type GetUserCredentials200ApplicationoctetStreamResponse struct {
	Body          io.Reader
	ContentLength int64
}

func (response GetUserCredentials200ApplicationoctetStreamResponse) VisitGetUserCredentialsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/octet-stream")
	if response.ContentLength != 0 {
		ctx.Response().Header.Set("Content-Length", fmt.Sprint(response.ContentLength))
	}
	ctx.Status(200)

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

type GetUserCredentialsdefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetUserCredentialsdefaultJSONResponse) VisitGetUserCredentialsResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type GetUserTokenRequestObject struct {
	UserId UserId `json:"userId"`
}

type GetUserTokenResponseObject interface {
	VisitGetUserTokenResponse(ctx *fiber.Ctx) error
}

type GetUserToken200JSONResponse JWTToken

func (response GetUserToken200JSONResponse) VisitGetUserTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type GetUserTokendefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response GetUserTokendefaultJSONResponse) VisitGetUserTokenResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

type VersionRequestObject struct {
}

type VersionResponseObject interface {
	VisitVersionResponse(ctx *fiber.Ctx) error
}

type Version200JSONResponse Version

func (response Version200JSONResponse) VisitVersionResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(200)

	return ctx.JSON(&response)
}

type VersiondefaultJSONResponse struct {
	Body       Error
	StatusCode int
}

func (response VersiondefaultJSONResponse) VisitVersionResponse(ctx *fiber.Ctx) error {
	ctx.Response().Header.Set("Content-Type", "application/json")
	ctx.Status(response.StatusCode)

	return ctx.JSON(&response.Body)
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// List all accounts
	// (GET /accounts)
	ListAccounts(ctx context.Context, request ListAccountsRequestObject) (ListAccountsResponseObject, error)
	// Creates a new account
	// (POST /accounts)
	CreateAccount(ctx context.Context, request CreateAccountRequestObject) (CreateAccountResponseObject, error)
	// Deletes an account by ID
	// (DELETE /accounts/{accountId})
	DeleteAccount(ctx context.Context, request DeleteAccountRequestObject) (DeleteAccountResponseObject, error)
	// Gets an account by ID
	// (GET /accounts/{accountId})
	GetAccount(ctx context.Context, request GetAccountRequestObject) (GetAccountResponseObject, error)
	// Updates an account by ID
	// (PUT /accounts/{accountId})
	UpdateAccount(ctx context.Context, request UpdateAccountRequestObject) (UpdateAccountResponseObject, error)
	// Deletes a signing key group by ID
	// (DELETE /accounts/{accountId}/groups)
	DeleteAccountSigningKeyGroup(ctx context.Context, request DeleteAccountSigningKeyGroupRequestObject) (DeleteAccountSigningKeyGroupResponseObject, error)
	// List all signing key groups for an account
	// (GET /accounts/{accountId}/groups)
	ListAccountSigningKeyGroups(ctx context.Context, request ListAccountSigningKeyGroupsRequestObject) (ListAccountSigningKeyGroupsResponseObject, error)
	// Creates a new signing key group
	// (POST /accounts/{accountId}/groups)
	CreateAccountSigningKeyGroup(ctx context.Context, request CreateAccountSigningKeyGroupRequestObject) (CreateAccountSigningKeyGroupResponseObject, error)
	// Gets a token for an account
	// (GET /accounts/{accountId}/token)
	GetAccountToken(ctx context.Context, request GetAccountTokenRequestObject) (GetAccountTokenResponseObject, error)
	// List all operators
	// (GET /operators)
	ListOperators(ctx context.Context, request ListOperatorsRequestObject) (ListOperatorsResponseObject, error)
	// Creates a new operator
	// (POST /operators)
	CreateOperator(ctx context.Context, request CreateOperatorRequestObject) (CreateOperatorResponseObject, error)
	// Deletes an operator by ID
	// (DELETE /operators/{operatorId})
	DeleteOperator(ctx context.Context, request DeleteOperatorRequestObject) (DeleteOperatorResponseObject, error)
	// Gets an operator by ID
	// (GET /operators/{operatorId})
	GetOperator(ctx context.Context, request GetOperatorRequestObject) (GetOperatorResponseObject, error)
	// Updates an operator by ID
	// (PUT /operators/{operatorId})
	UpdateOperator(ctx context.Context, request UpdateOperatorRequestObject) (UpdateOperatorResponseObject, error)
	// List all signing key groups for an operator
	// (GET /operators/{operatorId}/groups)
	ListOperatorSigningKeyGroups(ctx context.Context, request ListOperatorSigningKeyGroupsRequestObject) (ListOperatorSigningKeyGroupsResponseObject, error)
	// Creates a new signing key group
	// (POST /operators/{operatorId}/groups)
	CreateOperatorSigningKeyGroup(ctx context.Context, request CreateOperatorSigningKeyGroupRequestObject) (CreateOperatorSigningKeyGroupResponseObject, error)
	// Gets the system account for an operator
	// (GET /operators/{operatorId}/system-account)
	GetOperatorSystemAccount(ctx context.Context, request GetOperatorSystemAccountRequestObject) (GetOperatorSystemAccountResponseObject, error)
	// Updates the system account for an operator
	// (PUT /operators/{operatorId}/system-account)
	UpdateOperatorSystemAccount(ctx context.Context, request UpdateOperatorSystemAccountRequestObject) (UpdateOperatorSystemAccountResponseObject, error)
	// Gets a token for an operator
	// (GET /operators/{operatorId}/token)
	GetOperatorToken(ctx context.Context, request GetOperatorTokenRequestObject) (GetOperatorTokenResponseObject, error)
	// List all managed systems.
	// (GET /systems)
	ListSystems(ctx context.Context, request ListSystemsRequestObject) (ListSystemsResponseObject, error)
	// Creates a new system
	// (POST /systems)
	CreateSystem(ctx context.Context, request CreateSystemRequestObject) (CreateSystemResponseObject, error)
	// Deletes a system by ID
	// (DELETE /systems/{systemId})
	DeleteSystem(ctx context.Context, request DeleteSystemRequestObject) (DeleteSystemResponseObject, error)
	// Gets a system by ID
	// (GET /systems/{systemId})
	GetSystem(ctx context.Context, request GetSystemRequestObject) (GetSystemResponseObject, error)
	// Updates a system by ID
	// (PUT /systems/{systemId})
	UpdateSystem(ctx context.Context, request UpdateSystemRequestObject) (UpdateSystemResponseObject, error)
	// Deletes the operator for a system
	// (DELETE /systems/{systemId}/operator)
	DeleteSystemOperator(ctx context.Context, request DeleteSystemOperatorRequestObject) (DeleteSystemOperatorResponseObject, error)
	// Gets the operator for a system
	// (GET /systems/{systemId}/operator)
	GetSystemOperator(ctx context.Context, request GetSystemOperatorRequestObject) (GetSystemOperatorResponseObject, error)
	// Updates the operator for a system
	// (PUT /systems/{systemId}/operator)
	UpdateSystemOperator(ctx context.Context, request UpdateSystemOperatorRequestObject) (UpdateSystemOperatorResponseObject, error)
	// List all teams
	// (GET /teams)
	ListTeams(ctx context.Context, request ListTeamsRequestObject) (ListTeamsResponseObject, error)
	// Creates a new team
	// (POST /teams)
	CreateTeam(ctx context.Context, request CreateTeamRequestObject) (CreateTeamResponseObject, error)
	// Deletes a team by ID
	// (DELETE /teams/{teamId})
	DeleteTeam(ctx context.Context, request DeleteTeamRequestObject) (DeleteTeamResponseObject, error)
	// Gets a team by ID
	// (GET /teams/{teamId})
	GetTeam(ctx context.Context, request GetTeamRequestObject) (GetTeamResponseObject, error)
	// List all accounts for a team
	// (GET /teams/{teamId}/accounts)
	ListTeamAccounts(ctx context.Context, request ListTeamAccountsRequestObject) (ListTeamAccountsResponseObject, error)
	// List all systems for a team
	// (GET /teams/{teamId}/systems)
	ListTeamSystems(ctx context.Context, request ListTeamSystemsRequestObject) (ListTeamSystemsResponseObject, error)
	// List all users
	// (GET /users)
	ListUsers(ctx context.Context, request ListUsersRequestObject) (ListUsersResponseObject, error)
	// Creates a new user
	// (POST /users)
	CreateUser(ctx context.Context, request CreateUserRequestObject) (CreateUserResponseObject, error)
	// Deletes a user by ID
	// (DELETE /users/{userId})
	DeleteUser(ctx context.Context, request DeleteUserRequestObject) (DeleteUserResponseObject, error)
	// Gets a user by ID
	// (GET /users/{userId})
	GetUser(ctx context.Context, request GetUserRequestObject) (GetUserResponseObject, error)
	// Updates a user by ID
	// (PUT /users/{userId})
	UpdateUser(ctx context.Context, request UpdateUserRequestObject) (UpdateUserResponseObject, error)
	// Gets the credentials for a user
	// (GET /users/{userId}/credentials)
	GetUserCredentials(ctx context.Context, request GetUserCredentialsRequestObject) (GetUserCredentialsResponseObject, error)
	// Gets a token for a user
	// (GET /users/{userId}/token)
	GetUserToken(ctx context.Context, request GetUserTokenRequestObject) (GetUserTokenResponseObject, error)
	// Returns the current version of the API.
	// (GET /version)
	Version(ctx context.Context, request VersionRequestObject) (VersionResponseObject, error)
}

type StrictHandlerFunc func(ctx *fiber.Ctx, args interface{}) (interface{}, error)

type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc

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

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
}

// ListAccounts operation middleware
func (sh *strictHandler) ListAccounts(ctx *fiber.Ctx, params ListAccountsParams) error {
	var request ListAccountsRequestObject

	request.Params = params

	var body ListAccountsJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListAccounts(ctx.UserContext(), request.(ListAccountsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListAccounts")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListAccountsResponseObject); ok {
		if err := validResponse.VisitListAccountsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateAccount operation middleware
func (sh *strictHandler) CreateAccount(ctx *fiber.Ctx) error {
	var request CreateAccountRequestObject

	var body CreateAccountJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateAccount(ctx.UserContext(), request.(CreateAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateAccountResponseObject); ok {
		if err := validResponse.VisitCreateAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteAccount operation middleware
func (sh *strictHandler) DeleteAccount(ctx *fiber.Ctx, accountId AccountId) error {
	var request DeleteAccountRequestObject

	request.AccountId = accountId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteAccount(ctx.UserContext(), request.(DeleteAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteAccountResponseObject); ok {
		if err := validResponse.VisitDeleteAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetAccount operation middleware
func (sh *strictHandler) GetAccount(ctx *fiber.Ctx, accountId AccountId) error {
	var request GetAccountRequestObject

	request.AccountId = accountId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetAccount(ctx.UserContext(), request.(GetAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetAccountResponseObject); ok {
		if err := validResponse.VisitGetAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateAccount operation middleware
func (sh *strictHandler) UpdateAccount(ctx *fiber.Ctx, accountId AccountId) error {
	var request UpdateAccountRequestObject

	request.AccountId = accountId

	var body UpdateAccountJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateAccount(ctx.UserContext(), request.(UpdateAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateAccountResponseObject); ok {
		if err := validResponse.VisitUpdateAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteAccountSigningKeyGroup operation middleware
func (sh *strictHandler) DeleteAccountSigningKeyGroup(ctx *fiber.Ctx, accountId AccountId) error {
	var request DeleteAccountSigningKeyGroupRequestObject

	request.AccountId = accountId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteAccountSigningKeyGroup(ctx.UserContext(), request.(DeleteAccountSigningKeyGroupRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteAccountSigningKeyGroup")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteAccountSigningKeyGroupResponseObject); ok {
		if err := validResponse.VisitDeleteAccountSigningKeyGroupResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListAccountSigningKeyGroups operation middleware
func (sh *strictHandler) ListAccountSigningKeyGroups(ctx *fiber.Ctx, accountId AccountId, params ListAccountSigningKeyGroupsParams) error {
	var request ListAccountSigningKeyGroupsRequestObject

	request.AccountId = accountId
	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListAccountSigningKeyGroups(ctx.UserContext(), request.(ListAccountSigningKeyGroupsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListAccountSigningKeyGroups")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListAccountSigningKeyGroupsResponseObject); ok {
		if err := validResponse.VisitListAccountSigningKeyGroupsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateAccountSigningKeyGroup operation middleware
func (sh *strictHandler) CreateAccountSigningKeyGroup(ctx *fiber.Ctx, accountId AccountId) error {
	var request CreateAccountSigningKeyGroupRequestObject

	request.AccountId = accountId

	var body CreateAccountSigningKeyGroupJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateAccountSigningKeyGroup(ctx.UserContext(), request.(CreateAccountSigningKeyGroupRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateAccountSigningKeyGroup")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateAccountSigningKeyGroupResponseObject); ok {
		if err := validResponse.VisitCreateAccountSigningKeyGroupResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetAccountToken operation middleware
func (sh *strictHandler) GetAccountToken(ctx *fiber.Ctx, accountId AccountId) error {
	var request GetAccountTokenRequestObject

	request.AccountId = accountId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetAccountToken(ctx.UserContext(), request.(GetAccountTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetAccountToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetAccountTokenResponseObject); ok {
		if err := validResponse.VisitGetAccountTokenResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListOperators operation middleware
func (sh *strictHandler) ListOperators(ctx *fiber.Ctx, params ListOperatorsParams) error {
	var request ListOperatorsRequestObject

	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListOperators(ctx.UserContext(), request.(ListOperatorsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListOperators")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListOperatorsResponseObject); ok {
		if err := validResponse.VisitListOperatorsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateOperator operation middleware
func (sh *strictHandler) CreateOperator(ctx *fiber.Ctx) error {
	var request CreateOperatorRequestObject

	var body CreateOperatorJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateOperator(ctx.UserContext(), request.(CreateOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateOperatorResponseObject); ok {
		if err := validResponse.VisitCreateOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteOperator operation middleware
func (sh *strictHandler) DeleteOperator(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request DeleteOperatorRequestObject

	request.OperatorId = operatorId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteOperator(ctx.UserContext(), request.(DeleteOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteOperatorResponseObject); ok {
		if err := validResponse.VisitDeleteOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetOperator operation middleware
func (sh *strictHandler) GetOperator(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request GetOperatorRequestObject

	request.OperatorId = operatorId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetOperator(ctx.UserContext(), request.(GetOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetOperatorResponseObject); ok {
		if err := validResponse.VisitGetOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateOperator operation middleware
func (sh *strictHandler) UpdateOperator(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request UpdateOperatorRequestObject

	request.OperatorId = operatorId

	var body UpdateOperatorJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateOperator(ctx.UserContext(), request.(UpdateOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateOperatorResponseObject); ok {
		if err := validResponse.VisitUpdateOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListOperatorSigningKeyGroups operation middleware
func (sh *strictHandler) ListOperatorSigningKeyGroups(ctx *fiber.Ctx, operatorId OperatorId, params ListOperatorSigningKeyGroupsParams) error {
	var request ListOperatorSigningKeyGroupsRequestObject

	request.OperatorId = operatorId
	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListOperatorSigningKeyGroups(ctx.UserContext(), request.(ListOperatorSigningKeyGroupsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListOperatorSigningKeyGroups")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListOperatorSigningKeyGroupsResponseObject); ok {
		if err := validResponse.VisitListOperatorSigningKeyGroupsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateOperatorSigningKeyGroup operation middleware
func (sh *strictHandler) CreateOperatorSigningKeyGroup(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request CreateOperatorSigningKeyGroupRequestObject

	request.OperatorId = operatorId

	var body CreateOperatorSigningKeyGroupJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateOperatorSigningKeyGroup(ctx.UserContext(), request.(CreateOperatorSigningKeyGroupRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateOperatorSigningKeyGroup")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateOperatorSigningKeyGroupResponseObject); ok {
		if err := validResponse.VisitCreateOperatorSigningKeyGroupResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetOperatorSystemAccount operation middleware
func (sh *strictHandler) GetOperatorSystemAccount(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request GetOperatorSystemAccountRequestObject

	request.OperatorId = operatorId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetOperatorSystemAccount(ctx.UserContext(), request.(GetOperatorSystemAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetOperatorSystemAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetOperatorSystemAccountResponseObject); ok {
		if err := validResponse.VisitGetOperatorSystemAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateOperatorSystemAccount operation middleware
func (sh *strictHandler) UpdateOperatorSystemAccount(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request UpdateOperatorSystemAccountRequestObject

	request.OperatorId = operatorId

	var body UpdateOperatorSystemAccountJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateOperatorSystemAccount(ctx.UserContext(), request.(UpdateOperatorSystemAccountRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateOperatorSystemAccount")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateOperatorSystemAccountResponseObject); ok {
		if err := validResponse.VisitUpdateOperatorSystemAccountResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetOperatorToken operation middleware
func (sh *strictHandler) GetOperatorToken(ctx *fiber.Ctx, operatorId OperatorId) error {
	var request GetOperatorTokenRequestObject

	request.OperatorId = operatorId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetOperatorToken(ctx.UserContext(), request.(GetOperatorTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetOperatorToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetOperatorTokenResponseObject); ok {
		if err := validResponse.VisitGetOperatorTokenResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListSystems operation middleware
func (sh *strictHandler) ListSystems(ctx *fiber.Ctx, params ListSystemsParams) error {
	var request ListSystemsRequestObject

	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListSystems(ctx.UserContext(), request.(ListSystemsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListSystems")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListSystemsResponseObject); ok {
		if err := validResponse.VisitListSystemsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateSystem operation middleware
func (sh *strictHandler) CreateSystem(ctx *fiber.Ctx) error {
	var request CreateSystemRequestObject

	var body CreateSystemJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateSystem(ctx.UserContext(), request.(CreateSystemRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateSystem")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateSystemResponseObject); ok {
		if err := validResponse.VisitCreateSystemResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteSystem operation middleware
func (sh *strictHandler) DeleteSystem(ctx *fiber.Ctx, systemId SystemId) error {
	var request DeleteSystemRequestObject

	request.SystemId = systemId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteSystem(ctx.UserContext(), request.(DeleteSystemRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteSystem")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteSystemResponseObject); ok {
		if err := validResponse.VisitDeleteSystemResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetSystem operation middleware
func (sh *strictHandler) GetSystem(ctx *fiber.Ctx, systemId SystemId) error {
	var request GetSystemRequestObject

	request.SystemId = systemId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetSystem(ctx.UserContext(), request.(GetSystemRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSystem")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetSystemResponseObject); ok {
		if err := validResponse.VisitGetSystemResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateSystem operation middleware
func (sh *strictHandler) UpdateSystem(ctx *fiber.Ctx, systemId SystemId) error {
	var request UpdateSystemRequestObject

	request.SystemId = systemId

	var body UpdateSystemJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateSystem(ctx.UserContext(), request.(UpdateSystemRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateSystem")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateSystemResponseObject); ok {
		if err := validResponse.VisitUpdateSystemResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteSystemOperator operation middleware
func (sh *strictHandler) DeleteSystemOperator(ctx *fiber.Ctx, systemId SystemId) error {
	var request DeleteSystemOperatorRequestObject

	request.SystemId = systemId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteSystemOperator(ctx.UserContext(), request.(DeleteSystemOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteSystemOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteSystemOperatorResponseObject); ok {
		if err := validResponse.VisitDeleteSystemOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetSystemOperator operation middleware
func (sh *strictHandler) GetSystemOperator(ctx *fiber.Ctx, systemId SystemId) error {
	var request GetSystemOperatorRequestObject

	request.SystemId = systemId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetSystemOperator(ctx.UserContext(), request.(GetSystemOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetSystemOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetSystemOperatorResponseObject); ok {
		if err := validResponse.VisitGetSystemOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateSystemOperator operation middleware
func (sh *strictHandler) UpdateSystemOperator(ctx *fiber.Ctx, systemId SystemId) error {
	var request UpdateSystemOperatorRequestObject

	request.SystemId = systemId

	var body UpdateSystemOperatorJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateSystemOperator(ctx.UserContext(), request.(UpdateSystemOperatorRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateSystemOperator")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateSystemOperatorResponseObject); ok {
		if err := validResponse.VisitUpdateSystemOperatorResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListTeams operation middleware
func (sh *strictHandler) ListTeams(ctx *fiber.Ctx, params ListTeamsParams) error {
	var request ListTeamsRequestObject

	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListTeams(ctx.UserContext(), request.(ListTeamsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListTeams")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListTeamsResponseObject); ok {
		if err := validResponse.VisitListTeamsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateTeam operation middleware
func (sh *strictHandler) CreateTeam(ctx *fiber.Ctx) error {
	var request CreateTeamRequestObject

	var body CreateTeamJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateTeam(ctx.UserContext(), request.(CreateTeamRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateTeam")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateTeamResponseObject); ok {
		if err := validResponse.VisitCreateTeamResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteTeam operation middleware
func (sh *strictHandler) DeleteTeam(ctx *fiber.Ctx, teamId TeamId) error {
	var request DeleteTeamRequestObject

	request.TeamId = teamId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteTeam(ctx.UserContext(), request.(DeleteTeamRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteTeam")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteTeamResponseObject); ok {
		if err := validResponse.VisitDeleteTeamResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetTeam operation middleware
func (sh *strictHandler) GetTeam(ctx *fiber.Ctx, teamId TeamId) error {
	var request GetTeamRequestObject

	request.TeamId = teamId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetTeam(ctx.UserContext(), request.(GetTeamRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetTeam")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetTeamResponseObject); ok {
		if err := validResponse.VisitGetTeamResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListTeamAccounts operation middleware
func (sh *strictHandler) ListTeamAccounts(ctx *fiber.Ctx, teamId TeamId, params ListTeamAccountsParams) error {
	var request ListTeamAccountsRequestObject

	request.TeamId = teamId
	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListTeamAccounts(ctx.UserContext(), request.(ListTeamAccountsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListTeamAccounts")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListTeamAccountsResponseObject); ok {
		if err := validResponse.VisitListTeamAccountsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListTeamSystems operation middleware
func (sh *strictHandler) ListTeamSystems(ctx *fiber.Ctx, teamId TeamId, params ListTeamSystemsParams) error {
	var request ListTeamSystemsRequestObject

	request.TeamId = teamId
	request.Params = params

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListTeamSystems(ctx.UserContext(), request.(ListTeamSystemsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListTeamSystems")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListTeamSystemsResponseObject); ok {
		if err := validResponse.VisitListTeamSystemsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// ListUsers operation middleware
func (sh *strictHandler) ListUsers(ctx *fiber.Ctx, params ListUsersParams) error {
	var request ListUsersRequestObject

	request.Params = params

	var body ListUsersJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.ListUsers(ctx.UserContext(), request.(ListUsersRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "ListUsers")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(ListUsersResponseObject); ok {
		if err := validResponse.VisitListUsersResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// CreateUser operation middleware
func (sh *strictHandler) CreateUser(ctx *fiber.Ctx) error {
	var request CreateUserRequestObject

	var body CreateUserJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.CreateUser(ctx.UserContext(), request.(CreateUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "CreateUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(CreateUserResponseObject); ok {
		if err := validResponse.VisitCreateUserResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// DeleteUser operation middleware
func (sh *strictHandler) DeleteUser(ctx *fiber.Ctx, userId UserId) error {
	var request DeleteUserRequestObject

	request.UserId = userId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.DeleteUser(ctx.UserContext(), request.(DeleteUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "DeleteUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(DeleteUserResponseObject); ok {
		if err := validResponse.VisitDeleteUserResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetUser operation middleware
func (sh *strictHandler) GetUser(ctx *fiber.Ctx, userId UserId) error {
	var request GetUserRequestObject

	request.UserId = userId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetUser(ctx.UserContext(), request.(GetUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetUserResponseObject); ok {
		if err := validResponse.VisitGetUserResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// UpdateUser operation middleware
func (sh *strictHandler) UpdateUser(ctx *fiber.Ctx, userId UserId) error {
	var request UpdateUserRequestObject

	request.UserId = userId

	var body UpdateUserJSONRequestBody
	if err := ctx.BodyParser(&body); err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}
	request.Body = &body

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.UpdateUser(ctx.UserContext(), request.(UpdateUserRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "UpdateUser")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(UpdateUserResponseObject); ok {
		if err := validResponse.VisitUpdateUserResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetUserCredentials operation middleware
func (sh *strictHandler) GetUserCredentials(ctx *fiber.Ctx, userId UserId) error {
	var request GetUserCredentialsRequestObject

	request.UserId = userId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetUserCredentials(ctx.UserContext(), request.(GetUserCredentialsRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUserCredentials")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetUserCredentialsResponseObject); ok {
		if err := validResponse.VisitGetUserCredentialsResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// GetUserToken operation middleware
func (sh *strictHandler) GetUserToken(ctx *fiber.Ctx, userId UserId) error {
	var request GetUserTokenRequestObject

	request.UserId = userId

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.GetUserToken(ctx.UserContext(), request.(GetUserTokenRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUserToken")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(GetUserTokenResponseObject); ok {
		if err := validResponse.VisitGetUserTokenResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}

// Version operation middleware
func (sh *strictHandler) Version(ctx *fiber.Ctx) error {
	var request VersionRequestObject

	handler := func(ctx *fiber.Ctx, request interface{}) (interface{}, error) {
		return sh.ssi.Version(ctx.UserContext(), request.(VersionRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "Version")
	}

	response, err := handler(ctx, request)

	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	} else if validResponse, ok := response.(VersionResponseObject); ok {
		if err := validResponse.VisitVersionResponse(ctx); err != nil {
			return fiber.NewError(fiber.StatusBadRequest, err.Error())
		}
	} else if response != nil {
		return fmt.Errorf("unexpected response type: %T", response)
	}
	return nil
}