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

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

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

// ServerInterface represents all server handlers.
type ServerInterface interface {

	// (GET /api/array)
	GetArray(ctx echo.Context, params GetArrayParams) error

	// (GET /api/auth/info)
	GetAuthInfo(ctx echo.Context) error
	// Refresh access token
	// (POST /api/auth/refresh)
	PostAuthRefresh(ctx echo.Context, params PostAuthRefreshParams) error
	// Get a new access token
	// (POST /api/auth/token)
	PostAuthToken(ctx echo.Context, params PostAuthTokenParams) error

	// (GET /api/auth/whoami)
	GetAuthWhoAmI(ctx echo.Context) error

	// (POST /api/cluster/action/abort)
	PostClusterActionAbort(ctx echo.Context) error

	// (POST /api/cluster/action/freeze)
	PostClusterActionFreeze(ctx echo.Context) error

	// (POST /api/cluster/action/unfreeze)
	PostClusterActionUnfreeze(ctx echo.Context) error

	// (GET /api/cluster/config)
	GetClusterConfig(ctx echo.Context, params GetClusterConfigParams) error

	// (PATCH /api/cluster/config)
	PatchClusterConfig(ctx echo.Context, params PatchClusterConfigParams) error

	// (GET /api/cluster/config/file)
	GetClusterConfigFile(ctx echo.Context) error

	// (PUT /api/cluster/config/file)
	PutClusterConfigFile(ctx echo.Context) error

	// (GET /api/cluster/config/keywords)
	GetClusterConfigKeywords(ctx echo.Context, params GetClusterConfigKeywordsParams) error

	// (POST /api/cluster/hb/rotate)
	PostClusterHeartbeatRotate(ctx echo.Context) error

	// (POST /api/cluster/join)
	PostClusterJoin(ctx echo.Context, params PostClusterJoinParams) error

	// (POST /api/cluster/leave)
	PostClusterLeave(ctx echo.Context, params PostClusterLeaveParams) error

	// (GET /api/cluster/status)
	GetClusterStatus(ctx echo.Context, params GetClusterStatusParams) error

	// (GET /api/instance)
	GetInstances(ctx echo.Context, params GetInstancesParams) error

	// (POST /api/instance/path/{namespace}/{kind}/{name}/progress)
	PostInstanceProgress(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/instance/path/{namespace}/{kind}/{name}/status)
	PostInstanceStatus(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/network)
	GetNetworks(ctx echo.Context, params GetNetworksParams) error

	// (GET /api/network/ip)
	GetNetworkIP(ctx echo.Context, params GetNetworkIPParams) error

	// (GET /api/node)
	GetNodes(ctx echo.Context, params GetNodesParams) error

	// (GET /api/node/info)
	GetNodesInfo(ctx echo.Context) error

	// (POST /api/node/name/{nodename}/action/abort)
	PostPeerActionAbort(ctx echo.Context, nodename InPathNodeName) error

	// (POST /api/node/name/{nodename}/action/clear)
	PostNodeActionClear(ctx echo.Context, nodename InPathNodeName) error

	// (POST /api/node/name/{nodename}/action/drain)
	PostPeerActionDrain(ctx echo.Context, nodename InPathNodeName) error

	// (POST /api/node/name/{nodename}/action/freeze)
	PostPeerActionFreeze(ctx echo.Context, nodename InPathNodeName, params PostPeerActionFreezeParams) error

	// (POST /api/node/name/{nodename}/action/push/asset)
	PostNodeActionPushAsset(ctx echo.Context, nodename InPathNodeName, params PostNodeActionPushAssetParams) error

	// (POST /api/node/name/{nodename}/action/push/disk)
	PostNodeActionPushDisk(ctx echo.Context, nodename InPathNodeName, params PostNodeActionPushDiskParams) error

	// (POST /api/node/name/{nodename}/action/push/patch)
	PostNodeActionPushPatch(ctx echo.Context, nodename InPathNodeName, params PostNodeActionPushPatchParams) error

	// (POST /api/node/name/{nodename}/action/push/pkg)
	PostNodeActionPushPkg(ctx echo.Context, nodename InPathNodeName, params PostNodeActionPushPkgParams) error

	// (POST /api/node/name/{nodename}/action/scan/capabilities)
	PostNodeActionScanCapabilities(ctx echo.Context, nodename InPathNodeName, params PostNodeActionScanCapabilitiesParams) error

	// (POST /api/node/name/{nodename}/action/sysreport)
	PostNodeActionSysreport(ctx echo.Context, nodename InPathNodeName, params PostNodeActionSysreportParams) error

	// (POST /api/node/name/{nodename}/action/unfreeze)
	PostPeerActionUnfreeze(ctx echo.Context, nodename InPathNodeName, params PostPeerActionUnfreezeParams) error

	// (GET /api/node/name/{nodename}/capabilities)
	GetNodeCapabilities(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/config)
	GetNodeConfig(ctx echo.Context, nodename InPathNodeName, params GetNodeConfigParams) error

	// (PATCH /api/node/name/{nodename}/config)
	PatchNodeConfig(ctx echo.Context, nodename InPathNodeName, params PatchNodeConfigParams) error

	// (GET /api/node/name/{nodename}/config/file)
	GetNodeConfigFile(ctx echo.Context, nodename InPathNodeName) error

	// (PUT /api/node/name/{nodename}/config/file)
	PutNodeConfigFile(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/config/keywords)
	GetNodeConfigKeywords(ctx echo.Context, nodename InPathNodeName, params GetNodeConfigKeywordsParams) error

	// (POST /api/node/name/{nodename}/daemon/action/restart)
	PostDaemonRestart(ctx echo.Context, nodename InPathNodeName) error

	// (POST /api/node/name/{nodename}/daemon/action/shutdown)
	PostDaemonShutdown(ctx echo.Context, nodename InPathNodeName, params PostDaemonShutdownParams) error

	// (POST /api/node/name/{nodename}/daemon/action/stop)
	PostDaemonStop(ctx echo.Context, nodename InPathNodeName) error

	// (POST /api/node/name/{nodename}/daemon/audit)
	PostDaemonAudit(ctx echo.Context, nodename InPathNodeName, params PostDaemonAuditParams) error

	// (GET /api/node/name/{nodename}/daemon/dns/dump)
	GetDaemonDNSDump(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/daemon/event)
	GetDaemonEvents(ctx echo.Context, nodename InPathNodeName, params GetDaemonEventsParams) error

	// (POST /api/node/name/{nodename}/daemon/hb/name/{name}/action/restart)
	PostDaemonHeartbeatRestart(ctx echo.Context, nodename InPathNodeName, name InPathHeartbeatName) error

	// (POST /api/node/name/{nodename}/daemon/hb/name/{name}/action/sign)
	PostDaemonHeartbeatSign(ctx echo.Context, nodename InPathNodeName, name InPathHeartbeatName) error

	// (POST /api/node/name/{nodename}/daemon/hb/name/{name}/action/start)
	PostDaemonHeartbeatStart(ctx echo.Context, nodename InPathNodeName, name InPathHeartbeatName) error

	// (POST /api/node/name/{nodename}/daemon/hb/name/{name}/action/stop)
	PostDaemonHeartbeatStop(ctx echo.Context, nodename InPathNodeName, name InPathHeartbeatName) error

	// (POST /api/node/name/{nodename}/daemon/hb/name/{name}/action/wipe)
	PostDaemonHeartbeatWipe(ctx echo.Context, nodename InPathNodeName, name InPathHeartbeatName) error

	// (POST /api/node/name/{nodename}/daemon/listener/name/{name}/action/restart)
	PostDaemonListenerRestart(ctx echo.Context, nodename InPathNodeName, name InPathListenerName) error

	// (POST /api/node/name/{nodename}/daemon/listener/name/{name}/action/start)
	PostDaemonListenerStart(ctx echo.Context, nodename InPathNodeName, name InPathListenerName) error

	// (POST /api/node/name/{nodename}/daemon/listener/name/{name}/action/stop)
	PostDaemonListenerStop(ctx echo.Context, nodename InPathNodeName, name InPathListenerName) error

	// (POST /api/node/name/{nodename}/daemon/listener/name/{name}/log/control)
	PostDaemonListenerLogControl(ctx echo.Context, nodename InPathNodeName, name InPathListenerName) error

	// (POST /api/node/name/{nodename}/daemon/log/control)
	PostDaemonLogControl(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/drbd/allocation)
	GetNodeDRBDAllocation(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/drbd/config)
	GetNodeDRBDConfig(ctx echo.Context, nodename InPathNodeName, params GetNodeDRBDConfigParams) error

	// (POST /api/node/name/{nodename}/drbd/config)
	PostNodeDRBDConfig(ctx echo.Context, nodename InPathNodeName, params PostNodeDRBDConfigParams) error

	// (POST /api/node/name/{nodename}/drbd/connect)
	PostNodeDRBDConnect(ctx echo.Context, nodename InPathNodeName, params PostNodeDRBDConnectParams) error

	// (POST /api/node/name/{nodename}/drbd/primary)
	PostNodeDRBDPrimary(ctx echo.Context, nodename InPathNodeName, params PostNodeDRBDPrimaryParams) error

	// (POST /api/node/name/{nodename}/drbd/secondary)
	PostNodeDRBDSecondary(ctx echo.Context, nodename InPathNodeName, params PostNodeDRBDSecondaryParams) error

	// (GET /api/node/name/{nodename}/drivers)
	GetNodeDriver(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name})
	GetInstance(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/boot)
	PostInstanceActionBoot(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionBootParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/delete)
	PostInstanceActionDelete(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionDeleteParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/freeze)
	PostInstanceActionFreeze(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionFreezeParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/provision)
	PostInstanceActionProvision(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionProvisionParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/prstart)
	PostInstanceActionPRStart(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionPRStartParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/prstop)
	PostInstanceActionPRStop(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionPRStopParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/push/resource/info)
	PostInstanceActionPushResourceInfo(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionPushResourceInfoParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/restart)
	PostInstanceActionRestart(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionRestartParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/run)
	PostInstanceActionRun(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionRunParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/shutdown)
	PostInstanceActionShutdown(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionShutdownParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/start)
	PostInstanceActionStart(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionStartParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/startstandby)
	PostInstanceActionStartStandby(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionStartStandbyParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/status)
	PostInstanceActionStatus(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionStatusParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/stop)
	PostInstanceActionStop(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionStopParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/sync/ingest)
	PostInstanceActionSyncIngest(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionSyncIngestParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/unfreeze)
	PostInstanceActionUnfreeze(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionUnfreezeParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/action/unprovision)
	PostInstanceActionUnprovision(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceActionUnprovisionParams) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/clear)
	PostInstanceClear(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/config/file)
	GetInstanceConfigFile(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/console)
	PostInstanceResourceConsole(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params PostInstanceResourceConsoleParams) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/log)
	GetInstanceLogs(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params GetInstanceLogsParams) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/resource/file)
	GetInstanceResourceFile(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName, params GetInstanceResourceFileParams) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/resource/info)
	GetInstanceResourceInfo(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/schedule)
	GetInstanceSchedule(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/node/name/{nodename}/instance/path/{namespace}/{kind}/{name}/state/file)
	PostInstanceStateFile(ctx echo.Context, nodename InPathNodeName, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/node/name/{nodename}/log)
	GetNodeLogs(ctx echo.Context, nodename InPathNodeName, params GetNodeLogsParams) error

	// (GET /api/node/name/{nodename}/ping)
	GetNodePing(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/schedule)
	GetNodeSchedule(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/ssh/hostkeys)
	GetNodeSSHHostkeys(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/ssh/key)
	GetNodeSSHKey(ctx echo.Context, nodename InPathNodeName) error

	// (PUT /api/node/name/{nodename}/ssh/trust)
	PutNodeSSHTrust(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/disk)
	GetNodeSystemDisk(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/group)
	GetNodeSystemGroup(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/hardware)
	GetNodeSystemHardware(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/ipaddress)
	GetNodeSystemIPAddress(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/package)
	GetNodeSystemPackage(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/patch)
	GetNodeSystemPatch(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/property)
	GetNodeSystemProperty(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/san/initiator)
	GetNodeSystemSANInitiator(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/san/path)
	GetNodeSystemSANPath(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/node/name/{nodename}/system/user)
	GetNodeSystemUser(ctx echo.Context, nodename InPathNodeName) error

	// (GET /api/object)
	GetObjects(ctx echo.Context, params GetObjectsParams) error

	// (GET /api/object/path)
	GetObjectPaths(ctx echo.Context, params GetObjectPathsParams) error

	// (POST /api/object/path/{namespace}/svc/{name}/disable)
	PostSvcDisable(ctx echo.Context, namespace InPathNamespace, name InPathName, params PostSvcDisableParams) error

	// (POST /api/object/path/{namespace}/svc/{name}/enable)
	PostSvcEnable(ctx echo.Context, namespace InPathNamespace, name InPathName, params PostSvcEnableParams) error

	// (GET /api/object/path/{namespace}/{kind}/{name})
	GetObject(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/abort)
	PostObjectActionAbort(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/delete)
	PostObjectActionDelete(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/freeze)
	PostObjectActionFreeze(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/giveback)
	PostObjectActionGiveback(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/provision)
	PostObjectActionProvision(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/purge)
	PostObjectActionPurge(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/restart)
	PostObjectActionRestart(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/start)
	PostObjectActionStart(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/stop)
	PostObjectActionStop(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/switch)
	PostObjectActionSwitch(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/unfreeze)
	PostObjectActionUnfreeze(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/action/unprovision)
	PostObjectActionUnprovision(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/config)
	GetObjectConfig(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectConfigParams) error

	// (PATCH /api/object/path/{namespace}/{kind}/{name}/config)
	PatchObjectConfig(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PatchObjectConfigParams) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/config/file)
	GetObjectConfigFile(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/config/file)
	PostObjectConfigFile(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (PUT /api/object/path/{namespace}/{kind}/{name}/config/file)
	PutObjectConfigFile(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/config/keywords)
	GetObjectConfigKeywords(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectConfigKeywordsParams) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/data)
	GetObjectData(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectDataParams) error

	// (PATCH /api/object/path/{namespace}/{kind}/{name}/data)
	PatchObjectData(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (DELETE /api/object/path/{namespace}/{kind}/{name}/data/key)
	DeleteObjectDataKey(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params DeleteObjectDataKeyParams) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/data/key)
	GetObjectDataKey(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params GetObjectDataKeyParams) error

	// (POST /api/object/path/{namespace}/{kind}/{name}/data/key)
	PostObjectDataKey(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PostObjectDataKeyParams) error

	// (PUT /api/object/path/{namespace}/{kind}/{name}/data/key)
	PutObjectDataKey(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName, params PutObjectDataKeyParams) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/data/keys)
	GetObjectDataKeys(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/resource/info)
	GetObjectResourceInfo(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/object/path/{namespace}/{kind}/{name}/schedule)
	GetObjectSchedule(ctx echo.Context, namespace InPathNamespace, kind InPathKind, name InPathName) error

	// (GET /api/openapi)
	GetSwagger(ctx echo.Context) error

	// (GET /api/pool)
	GetPools(ctx echo.Context, params GetPoolsParams) error

	// (GET /api/pool/volume)
	GetPoolVolumes(ctx echo.Context, params GetPoolVolumesParams) error

	// (GET /api/relay/message)
	GetRelayMessage(ctx echo.Context, params GetRelayMessageParams) error

	// (POST /api/relay/message)
	PostRelayMessage(ctx echo.Context) error

	// (GET /api/relay/status)
	GetRelayStatus(ctx echo.Context, params GetRelayStatusParams) error

	// (GET /api/resource)
	GetResources(ctx echo.Context, params GetResourcesParams) error
}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "role", ctx.QueryParams(), &params.Role, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter role: %s", err))
	}

	// ------------- Optional query parameter "access_duration" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "access_duration", ctx.QueryParams(), &params.AccessDuration, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter access_duration: %s", err))
	}

	// ------------- Optional query parameter "scope" -------------

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "role", ctx.QueryParams(), &params.Role, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter role: %s", err))
	}

	// ------------- Optional query parameter "access_duration" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "access_duration", ctx.QueryParams(), &params.AccessDuration, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter access_duration: %s", err))
	}

	// ------------- Optional query parameter "subject" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subject", ctx.QueryParams(), &params.Subject, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subject: %s", err))
	}

	// ------------- Optional query parameter "scope" -------------

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

	// ------------- Optional query parameter "refresh" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "refresh", ctx.QueryParams(), &params.Refresh, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter refresh: %s", err))
	}

	// ------------- Optional query parameter "refresh_duration" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "refresh_duration", ctx.QueryParams(), &params.RefreshDuration, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter refresh_duration: %s", err))
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "evaluate", ctx.QueryParams(), &params.Evaluate, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter evaluate: %s", err))
	}

	// ------------- Optional query parameter "impersonate" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "impersonate", ctx.QueryParams(), &params.Impersonate, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter impersonate: %s", err))
	}

	// ------------- Optional query parameter "kw" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "kw", ctx.QueryParams(), &params.Kw, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kw: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "delete", ctx.QueryParams(), &params.Delete, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter delete: %s", err))
	}

	// ------------- Optional query parameter "unset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "unset", ctx.QueryParams(), &params.Unset, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter unset: %s", err))
	}

	// ------------- Optional query parameter "set" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "set", ctx.QueryParams(), &params.Set, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter set: %s", err))
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "driver", ctx.QueryParams(), &params.Driver, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter driver: %s", err))
	}

	// ------------- Optional query parameter "section" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "section", ctx.QueryParams(), &params.Section, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter section: %s", err))
	}

	// ------------- Optional query parameter "option" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "option", ctx.QueryParams(), &params.Option, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter option: %s", err))
	}

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

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

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

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "namespace", ctx.QueryParams(), &params.Namespace, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter namespace: %s", err))
	}

	// ------------- Optional query parameter "selector" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "selector", ctx.QueryParams(), &params.Selector, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter selector: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "path", ctx.QueryParams(), &params.Path, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter path: %s", err))
	}

	// ------------- Optional query parameter "node" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

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

// PostInstanceProgress converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceProgress(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceProgress(ctx, namespace, kind, name)
	return err
}

// PostInstanceStatus converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceStatus(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceStatus(ctx, namespace, kind, name)
	return err
}

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

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

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

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

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

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

// PostPeerActionAbort converts echo context to params.
func (w *ServerInterfaceWrapper) PostPeerActionAbort(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PostNodeActionClear converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionClear(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PostPeerActionDrain converts echo context to params.
func (w *ServerInterfaceWrapper) PostPeerActionDrain(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PostPeerActionFreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostPeerActionFreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionPushAsset converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionPushAsset(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionPushDisk converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionPushDisk(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionPushPatch converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionPushPatch(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionPushPkg converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionPushPkg(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionScanCapabilities converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionScanCapabilities(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostNodeActionSysreport converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionSysreport(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// PostPeerActionUnfreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostPeerActionUnfreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

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

// GetNodeCapabilities converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeCapabilities(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeConfig converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "kw", ctx.QueryParams(), &params.Kw, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kw: %s", err))
	}

	// ------------- Optional query parameter "evaluate" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "evaluate", ctx.QueryParams(), &params.Evaluate, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter evaluate: %s", err))
	}

	// ------------- Optional query parameter "impersonate" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "impersonate", ctx.QueryParams(), &params.Impersonate, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter impersonate: %s", err))
	}

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

// PatchNodeConfig converts echo context to params.
func (w *ServerInterfaceWrapper) PatchNodeConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "delete", ctx.QueryParams(), &params.Delete, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter delete: %s", err))
	}

	// ------------- Optional query parameter "unset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "unset", ctx.QueryParams(), &params.Unset, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter unset: %s", err))
	}

	// ------------- Optional query parameter "set" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "set", ctx.QueryParams(), &params.Set, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter set: %s", err))
	}

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

// GetNodeConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PutNodeConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) PutNodeConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeConfigKeywords converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeConfigKeywords(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "driver", ctx.QueryParams(), &params.Driver, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter driver: %s", err))
	}

	// ------------- Optional query parameter "section" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "section", ctx.QueryParams(), &params.Section, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter section: %s", err))
	}

	// ------------- Optional query parameter "option" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "option", ctx.QueryParams(), &params.Option, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter option: %s", err))
	}

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

// PostDaemonRestart converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonRestart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PostDaemonShutdown converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonShutdown(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "duration", ctx.QueryParams(), &params.Duration, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter duration: %s", err))
	}

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

// PostDaemonStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PostDaemonAudit converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonAudit(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "level", ctx.QueryParams(), &params.Level, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter level: %s", err))
	}

	// ------------- Optional query parameter "sub" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "sub", ctx.QueryParams(), &params.Sub, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter sub: %s", err))
	}

	// ------------- Optional query parameter "preempt" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "preempt", ctx.QueryParams(), &params.Preempt, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter preempt: %s", err))
	}

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

// GetDaemonDNSDump converts echo context to params.
func (w *ServerInterfaceWrapper) GetDaemonDNSDump(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetDaemonEvents converts echo context to params.
func (w *ServerInterfaceWrapper) GetDaemonEvents(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "duration", ctx.QueryParams(), &params.Duration, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter duration: %s", err))
	}

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", ctx.QueryParams(), &params.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: "int64"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
	}

	// ------------- Optional query parameter "filter" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", ctx.QueryParams(), &params.Filter, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter filter: %s", err))
	}

	// ------------- Optional query parameter "cache" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "cache", ctx.QueryParams(), &params.Cache, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter cache: %s", err))
	}

	// ------------- Optional query parameter "selector" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "selector", ctx.QueryParams(), &params.Selector, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter selector: %s", err))
	}

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

// PostDaemonHeartbeatRestart converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonHeartbeatRestart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathHeartbeatName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonHeartbeatRestart(ctx, nodename, name)
	return err
}

// PostDaemonHeartbeatSign converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonHeartbeatSign(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathHeartbeatName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonHeartbeatSign(ctx, nodename, name)
	return err
}

// PostDaemonHeartbeatStart converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonHeartbeatStart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathHeartbeatName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonHeartbeatStart(ctx, nodename, name)
	return err
}

// PostDaemonHeartbeatStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonHeartbeatStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathHeartbeatName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonHeartbeatStop(ctx, nodename, name)
	return err
}

// PostDaemonHeartbeatWipe converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonHeartbeatWipe(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathHeartbeatName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonHeartbeatWipe(ctx, nodename, name)
	return err
}

// PostDaemonListenerRestart converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonListenerRestart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathListenerName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonListenerRestart(ctx, nodename, name)
	return err
}

// PostDaemonListenerStart converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonListenerStart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathListenerName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonListenerStart(ctx, nodename, name)
	return err
}

// PostDaemonListenerStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonListenerStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathListenerName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonListenerStop(ctx, nodename, name)
	return err
}

// PostDaemonListenerLogControl converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonListenerLogControl(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "name" -------------
	var name InPathListenerName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostDaemonListenerLogControl(ctx, nodename, name)
	return err
}

// PostDaemonLogControl converts echo context to params.
func (w *ServerInterfaceWrapper) PostDaemonLogControl(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeDRBDAllocation converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeDRBDAllocation(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeDRBDConfig converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeDRBDConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PostNodeDRBDConfig converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeDRBDConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PostNodeDRBDConnect converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeDRBDConnect(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

	// ------------- Optional query parameter "node_id" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "node_id", ctx.QueryParams(), &params.NodeId, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node_id: %s", err))
	}

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

// PostNodeDRBDPrimary converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeDRBDPrimary(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PostNodeDRBDSecondary converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeDRBDSecondary(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// GetNodeDriver converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeDriver(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetInstance converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstance(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstance(ctx, nodename, namespace, kind, name)
	return err
}

// PostInstanceActionBoot converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionBoot(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionBoot(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionDelete converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionDelete(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionDelete(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionFreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionFreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionFreeze(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionProvision converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionProvision(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "leader" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "leader", ctx.QueryParams(), &params.Leader, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter leader: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "state_only" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "state_only", ctx.QueryParams(), &params.StateOnly, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter state_only: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionProvision(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionPRStart converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionPRStart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionPRStart(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionPRStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionPRStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionPRStop(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionPushResourceInfo converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionPushResourceInfo(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionPushResourceInfo(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionRestart converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionRestart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionRestart(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionRun converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionRun(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "confirm" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "confirm", ctx.QueryParams(), &params.Confirm, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter confirm: %s", err))
	}

	// ------------- Optional query parameter "cron" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "cron", ctx.QueryParams(), &params.Cron, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter cron: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// ------------- Optional query parameter "env" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "env", ctx.QueryParams(), &params.Env, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter env: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionRun(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionShutdown converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionShutdown(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionShutdown(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionStart converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionStart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionStart(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionStartStandby converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionStartStandby(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "disable_rollback" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "disable_rollback", ctx.QueryParams(), &params.DisableRollback, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter disable_rollback: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionStartStandby(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionStatus converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionStatus(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionStatus(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "move-to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "move-to", ctx.QueryParams(), &params.MoveTo, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter move-to: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionStop(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionSyncIngest converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionSyncIngest(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionSyncIngest(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionUnfreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionUnfreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionUnfreeze(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceActionUnprovision converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceActionUnprovision(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slaves", ctx.QueryParams(), &params.Slaves, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slaves: %s", err))
	}

	// ------------- Optional query parameter "force" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "force", ctx.QueryParams(), &params.Force, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter force: %s", err))
	}

	// ------------- Optional query parameter "leader" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "leader", ctx.QueryParams(), &params.Leader, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter leader: %s", err))
	}

	// ------------- Optional query parameter "master" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "master", ctx.QueryParams(), &params.Master, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter master: %s", err))
	}

	// ------------- Optional query parameter "requester_sid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "requester_sid", ctx.QueryParams(), &params.RequesterSid, runtime.BindQueryParameterOptions{Type: "string", Format: "uuid"})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter requester_sid: %s", err))
	}

	// ------------- Optional query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "state_only" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "state_only", ctx.QueryParams(), &params.StateOnly, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter state_only: %s", err))
	}

	// ------------- Optional query parameter "slave" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "slave", ctx.QueryParams(), &params.Slave, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter slave: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

	// ------------- Optional query parameter "to" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "to", ctx.QueryParams(), &params.To, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter to: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceActionUnprovision(ctx, nodename, namespace, kind, name, params)
	return err
}

// PostInstanceClear converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceClear(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceClear(ctx, nodename, namespace, kind, name)
	return err
}

// GetInstanceConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstanceConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstanceConfigFile(ctx, nodename, namespace, kind, name)
	return err
}

// PostInstanceResourceConsole converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceResourceConsole(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "greet_timeout" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "greet_timeout", ctx.QueryParams(), &params.GreetTimeout, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter greet_timeout: %s", err))
	}

	// ------------- Optional query parameter "seats" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "seats", ctx.QueryParams(), &params.Seats, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter seats: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceResourceConsole(ctx, nodename, namespace, kind, name, params)
	return err
}

// GetInstanceLogs converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstanceLogs(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", ctx.QueryParams(), &params.Filter, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter filter: %s", err))
	}

	// ------------- Optional query parameter "follow" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "follow", ctx.QueryParams(), &params.Follow, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter follow: %s", err))
	}

	// ------------- Optional query parameter "lines" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "lines", ctx.QueryParams(), &params.Lines, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter lines: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstanceLogs(ctx, nodename, namespace, kind, name, params)
	return err
}

// GetInstanceResourceFile converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstanceResourceFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

	// ------------- Required query parameter "rid" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstanceResourceFile(ctx, nodename, namespace, kind, name, params)
	return err
}

// GetInstanceResourceInfo converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstanceResourceInfo(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstanceResourceInfo(ctx, nodename, namespace, kind, name)
	return err
}

// GetInstanceSchedule converts echo context to params.
func (w *ServerInterfaceWrapper) GetInstanceSchedule(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetInstanceSchedule(ctx, nodename, namespace, kind, name)
	return err
}

// PostInstanceStateFile converts echo context to params.
func (w *ServerInterfaceWrapper) PostInstanceStateFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostInstanceStateFile(ctx, nodename, namespace, kind, name)
	return err
}

// GetNodeLogs converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeLogs(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "filter", ctx.QueryParams(), &params.Filter, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter filter: %s", err))
	}

	// ------------- Optional query parameter "follow" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "follow", ctx.QueryParams(), &params.Follow, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter follow: %s", err))
	}

	// ------------- Optional query parameter "lines" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "lines", ctx.QueryParams(), &params.Lines, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter lines: %s", err))
	}

	// ------------- Optional query parameter "paths" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "paths", ctx.QueryParams(), &params.Paths, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter paths: %s", err))
	}

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

// GetNodePing converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodePing(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSchedule converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSchedule(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSSHHostkeys converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSSHHostkeys(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSSHKey converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSSHKey(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// PutNodeSSHTrust converts echo context to params.
func (w *ServerInterfaceWrapper) PutNodeSSHTrust(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemDisk converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemDisk(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemGroup converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemGroup(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemHardware converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemHardware(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemIPAddress converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemIPAddress(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemPackage converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemPackage(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemPatch converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemPatch(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemProperty converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemProperty(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemSANInitiator converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemSANInitiator(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemSANPath converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemSANPath(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

// GetNodeSystemUser converts echo context to params.
func (w *ServerInterfaceWrapper) GetNodeSystemUser(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "nodename" -------------
	var nodename InPathNodeName

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

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

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "path", ctx.QueryParams(), &params.Path, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter path: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "path", ctx.QueryParams(), &params.Path, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter path: %s", err))
	}

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

// PostSvcDisable converts echo context to params.
func (w *ServerInterfaceWrapper) PostSvcDisable(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

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

// PostSvcEnable converts echo context to params.
func (w *ServerInterfaceWrapper) PostSvcEnable(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "rid", ctx.QueryParams(), &params.Rid, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter rid: %s", err))
	}

	// ------------- Optional query parameter "subset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "subset", ctx.QueryParams(), &params.Subset, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subset: %s", err))
	}

	// ------------- Optional query parameter "tag" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "tag", ctx.QueryParams(), &params.Tag, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter tag: %s", err))
	}

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

// GetObject converts echo context to params.
func (w *ServerInterfaceWrapper) GetObject(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetObject(ctx, namespace, kind, name)
	return err
}

// PostObjectActionAbort converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionAbort(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionAbort(ctx, namespace, kind, name)
	return err
}

// PostObjectActionDelete converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionDelete(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionDelete(ctx, namespace, kind, name)
	return err
}

// PostObjectActionFreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionFreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionFreeze(ctx, namespace, kind, name)
	return err
}

// PostObjectActionGiveback converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionGiveback(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionGiveback(ctx, namespace, kind, name)
	return err
}

// PostObjectActionProvision converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionProvision(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionProvision(ctx, namespace, kind, name)
	return err
}

// PostObjectActionPurge converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionPurge(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionPurge(ctx, namespace, kind, name)
	return err
}

// PostObjectActionRestart converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionRestart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionRestart(ctx, namespace, kind, name)
	return err
}

// PostObjectActionStart converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionStart(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionStart(ctx, namespace, kind, name)
	return err
}

// PostObjectActionStop converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionStop(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionStop(ctx, namespace, kind, name)
	return err
}

// PostObjectActionSwitch converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionSwitch(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionSwitch(ctx, namespace, kind, name)
	return err
}

// PostObjectActionUnfreeze converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionUnfreeze(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionUnfreeze(ctx, namespace, kind, name)
	return err
}

// PostObjectActionUnprovision converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectActionUnprovision(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectActionUnprovision(ctx, namespace, kind, name)
	return err
}

// GetObjectConfig converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "evaluate", ctx.QueryParams(), &params.Evaluate, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter evaluate: %s", err))
	}

	// ------------- Optional query parameter "impersonate" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "impersonate", ctx.QueryParams(), &params.Impersonate, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter impersonate: %s", err))
	}

	// ------------- Optional query parameter "kw" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "kw", ctx.QueryParams(), &params.Kw, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter kw: %s", err))
	}

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

// PatchObjectConfig converts echo context to params.
func (w *ServerInterfaceWrapper) PatchObjectConfig(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "delete", ctx.QueryParams(), &params.Delete, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter delete: %s", err))
	}

	// ------------- Optional query parameter "unset" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "unset", ctx.QueryParams(), &params.Unset, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter unset: %s", err))
	}

	// ------------- Optional query parameter "set" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "set", ctx.QueryParams(), &params.Set, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter set: %s", err))
	}

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

// GetObjectConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetObjectConfigFile(ctx, namespace, kind, name)
	return err
}

// PostObjectConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostObjectConfigFile(ctx, namespace, kind, name)
	return err
}

// PutObjectConfigFile converts echo context to params.
func (w *ServerInterfaceWrapper) PutObjectConfigFile(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PutObjectConfigFile(ctx, namespace, kind, name)
	return err
}

// GetObjectConfigKeywords converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectConfigKeywords(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "driver", ctx.QueryParams(), &params.Driver, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter driver: %s", err))
	}

	// ------------- Optional query parameter "section" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "section", ctx.QueryParams(), &params.Section, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter section: %s", err))
	}

	// ------------- Optional query parameter "option" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "option", ctx.QueryParams(), &params.Option, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter option: %s", err))
	}

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

// GetObjectData converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectData(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Names, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PatchObjectData converts echo context to params.
func (w *ServerInterfaceWrapper) PatchObjectData(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PatchObjectData(ctx, namespace, kind, name)
	return err
}

// DeleteObjectDataKey converts echo context to params.
func (w *ServerInterfaceWrapper) DeleteObjectDataKey(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// GetObjectDataKey converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectDataKey(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PostObjectDataKey converts echo context to params.
func (w *ServerInterfaceWrapper) PostObjectDataKey(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// PutObjectDataKey converts echo context to params.
func (w *ServerInterfaceWrapper) PutObjectDataKey(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

// GetObjectDataKeys converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectDataKeys(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetObjectDataKeys(ctx, namespace, kind, name)
	return err
}

// GetObjectResourceInfo converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectResourceInfo(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetObjectResourceInfo(ctx, namespace, kind, name)
	return err
}

// GetObjectSchedule converts echo context to params.
func (w *ServerInterfaceWrapper) GetObjectSchedule(ctx echo.Context) error {
	var err error
	// ------------- Path parameter "namespace" -------------
	var namespace InPathNamespace

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

	// ------------- Path parameter "kind" -------------
	var kind InPathKind

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

	// ------------- Path parameter "name" -------------
	var name InPathName

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

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

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.GetObjectSchedule(ctx, namespace, kind, name)
	return err
}

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

	// ------------- Optional query parameter "node" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "name", ctx.QueryParams(), &params.Name, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter name: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, true, "nodename", ctx.QueryParams(), &params.Nodename, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter nodename: %s", err))
	}

	// ------------- Required query parameter "cluster_id" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, true, "cluster_id", ctx.QueryParams(), &params.ClusterID, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter cluster_id: %s", err))
	}

	// ------------- Optional query parameter "username" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "username", ctx.QueryParams(), &params.Username, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter username: %s", err))
	}

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

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

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

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

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "relay", ctx.QueryParams(), &params.Relays, runtime.BindQueryParameterOptions{Type: "array", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter relay: %s", err))
	}

	// ------------- Optional query parameter "remote" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "remote", ctx.QueryParams(), &params.Remote, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter remote: %s", err))
	}

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

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

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

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

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

	err = runtime.BindQueryParameterWithOptions("form", true, false, "path", ctx.QueryParams(), &params.Path, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter path: %s", err))
	}

	// ------------- Optional query parameter "node" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "node", ctx.QueryParams(), &params.Node, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter node: %s", err))
	}

	// ------------- Optional query parameter "resource" -------------

	err = runtime.BindQueryParameterWithOptions("form", true, false, "resource", ctx.QueryParams(), &params.Resource, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
	if err != nil {
		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter resource: %s", err))
	}

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

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

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

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

	wrapper := ServerInterfaceWrapper{
		Handler: si,
	}

	router.GET(baseURL+"/api/array", wrapper.GetArray)
	router.GET(baseURL+"/api/auth/info", wrapper.GetAuthInfo)
	router.POST(baseURL+"/api/auth/refresh", wrapper.PostAuthRefresh)
	router.POST(baseURL+"/api/auth/token", wrapper.PostAuthToken)
	router.GET(baseURL+"/api/auth/whoami", wrapper.GetAuthWhoAmI)
	router.POST(baseURL+"/api/cluster/action/abort", wrapper.PostClusterActionAbort)
	router.POST(baseURL+"/api/cluster/action/freeze", wrapper.PostClusterActionFreeze)
	router.POST(baseURL+"/api/cluster/action/unfreeze", wrapper.PostClusterActionUnfreeze)
	router.GET(baseURL+"/api/cluster/config", wrapper.GetClusterConfig)
	router.PATCH(baseURL+"/api/cluster/config", wrapper.PatchClusterConfig)
	router.GET(baseURL+"/api/cluster/config/file", wrapper.GetClusterConfigFile)
	router.PUT(baseURL+"/api/cluster/config/file", wrapper.PutClusterConfigFile)
	router.GET(baseURL+"/api/cluster/config/keywords", wrapper.GetClusterConfigKeywords)
	router.POST(baseURL+"/api/cluster/hb/rotate", wrapper.PostClusterHeartbeatRotate)
	router.POST(baseURL+"/api/cluster/join", wrapper.PostClusterJoin)
	router.POST(baseURL+"/api/cluster/leave", wrapper.PostClusterLeave)
	router.GET(baseURL+"/api/cluster/status", wrapper.GetClusterStatus)
	router.GET(baseURL+"/api/instance", wrapper.GetInstances)
	router.POST(baseURL+"/api/instance/path/:namespace/:kind/:name/progress", wrapper.PostInstanceProgress)
	router.POST(baseURL+"/api/instance/path/:namespace/:kind/:name/status", wrapper.PostInstanceStatus)
	router.GET(baseURL+"/api/network", wrapper.GetNetworks)
	router.GET(baseURL+"/api/network/ip", wrapper.GetNetworkIP)
	router.GET(baseURL+"/api/node", wrapper.GetNodes)
	router.GET(baseURL+"/api/node/info", wrapper.GetNodesInfo)
	router.POST(baseURL+"/api/node/name/:nodename/action/abort", wrapper.PostPeerActionAbort)
	router.POST(baseURL+"/api/node/name/:nodename/action/clear", wrapper.PostNodeActionClear)
	router.POST(baseURL+"/api/node/name/:nodename/action/drain", wrapper.PostPeerActionDrain)
	router.POST(baseURL+"/api/node/name/:nodename/action/freeze", wrapper.PostPeerActionFreeze)
	router.POST(baseURL+"/api/node/name/:nodename/action/push/asset", wrapper.PostNodeActionPushAsset)
	router.POST(baseURL+"/api/node/name/:nodename/action/push/disk", wrapper.PostNodeActionPushDisk)
	router.POST(baseURL+"/api/node/name/:nodename/action/push/patch", wrapper.PostNodeActionPushPatch)
	router.POST(baseURL+"/api/node/name/:nodename/action/push/pkg", wrapper.PostNodeActionPushPkg)
	router.POST(baseURL+"/api/node/name/:nodename/action/scan/capabilities", wrapper.PostNodeActionScanCapabilities)
	router.POST(baseURL+"/api/node/name/:nodename/action/sysreport", wrapper.PostNodeActionSysreport)
	router.POST(baseURL+"/api/node/name/:nodename/action/unfreeze", wrapper.PostPeerActionUnfreeze)
	router.GET(baseURL+"/api/node/name/:nodename/capabilities", wrapper.GetNodeCapabilities)
	router.GET(baseURL+"/api/node/name/:nodename/config", wrapper.GetNodeConfig)
	router.PATCH(baseURL+"/api/node/name/:nodename/config", wrapper.PatchNodeConfig)
	router.GET(baseURL+"/api/node/name/:nodename/config/file", wrapper.GetNodeConfigFile)
	router.PUT(baseURL+"/api/node/name/:nodename/config/file", wrapper.PutNodeConfigFile)
	router.GET(baseURL+"/api/node/name/:nodename/config/keywords", wrapper.GetNodeConfigKeywords)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/action/restart", wrapper.PostDaemonRestart)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/action/shutdown", wrapper.PostDaemonShutdown)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/action/stop", wrapper.PostDaemonStop)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/audit", wrapper.PostDaemonAudit)
	router.GET(baseURL+"/api/node/name/:nodename/daemon/dns/dump", wrapper.GetDaemonDNSDump)
	router.GET(baseURL+"/api/node/name/:nodename/daemon/event", wrapper.GetDaemonEvents)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/hb/name/:name/action/restart", wrapper.PostDaemonHeartbeatRestart)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/hb/name/:name/action/sign", wrapper.PostDaemonHeartbeatSign)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/hb/name/:name/action/start", wrapper.PostDaemonHeartbeatStart)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/hb/name/:name/action/stop", wrapper.PostDaemonHeartbeatStop)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/hb/name/:name/action/wipe", wrapper.PostDaemonHeartbeatWipe)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/listener/name/:name/action/restart", wrapper.PostDaemonListenerRestart)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/listener/name/:name/action/start", wrapper.PostDaemonListenerStart)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/listener/name/:name/action/stop", wrapper.PostDaemonListenerStop)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/listener/name/:name/log/control", wrapper.PostDaemonListenerLogControl)
	router.POST(baseURL+"/api/node/name/:nodename/daemon/log/control", wrapper.PostDaemonLogControl)
	router.GET(baseURL+"/api/node/name/:nodename/drbd/allocation", wrapper.GetNodeDRBDAllocation)
	router.GET(baseURL+"/api/node/name/:nodename/drbd/config", wrapper.GetNodeDRBDConfig)
	router.POST(baseURL+"/api/node/name/:nodename/drbd/config", wrapper.PostNodeDRBDConfig)
	router.POST(baseURL+"/api/node/name/:nodename/drbd/connect", wrapper.PostNodeDRBDConnect)
	router.POST(baseURL+"/api/node/name/:nodename/drbd/primary", wrapper.PostNodeDRBDPrimary)
	router.POST(baseURL+"/api/node/name/:nodename/drbd/secondary", wrapper.PostNodeDRBDSecondary)
	router.GET(baseURL+"/api/node/name/:nodename/drivers", wrapper.GetNodeDriver)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name", wrapper.GetInstance)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/boot", wrapper.PostInstanceActionBoot)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/delete", wrapper.PostInstanceActionDelete)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/freeze", wrapper.PostInstanceActionFreeze)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/provision", wrapper.PostInstanceActionProvision)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/prstart", wrapper.PostInstanceActionPRStart)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/prstop", wrapper.PostInstanceActionPRStop)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/push/resource/info", wrapper.PostInstanceActionPushResourceInfo)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/restart", wrapper.PostInstanceActionRestart)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/run", wrapper.PostInstanceActionRun)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/shutdown", wrapper.PostInstanceActionShutdown)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/start", wrapper.PostInstanceActionStart)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/startstandby", wrapper.PostInstanceActionStartStandby)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/status", wrapper.PostInstanceActionStatus)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/stop", wrapper.PostInstanceActionStop)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/sync/ingest", wrapper.PostInstanceActionSyncIngest)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/unfreeze", wrapper.PostInstanceActionUnfreeze)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/action/unprovision", wrapper.PostInstanceActionUnprovision)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/clear", wrapper.PostInstanceClear)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/config/file", wrapper.GetInstanceConfigFile)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/console", wrapper.PostInstanceResourceConsole)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/log", wrapper.GetInstanceLogs)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/resource/file", wrapper.GetInstanceResourceFile)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/resource/info", wrapper.GetInstanceResourceInfo)
	router.GET(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/schedule", wrapper.GetInstanceSchedule)
	router.POST(baseURL+"/api/node/name/:nodename/instance/path/:namespace/:kind/:name/state/file", wrapper.PostInstanceStateFile)
	router.GET(baseURL+"/api/node/name/:nodename/log", wrapper.GetNodeLogs)
	router.GET(baseURL+"/api/node/name/:nodename/ping", wrapper.GetNodePing)
	router.GET(baseURL+"/api/node/name/:nodename/schedule", wrapper.GetNodeSchedule)
	router.GET(baseURL+"/api/node/name/:nodename/ssh/hostkeys", wrapper.GetNodeSSHHostkeys)
	router.GET(baseURL+"/api/node/name/:nodename/ssh/key", wrapper.GetNodeSSHKey)
	router.PUT(baseURL+"/api/node/name/:nodename/ssh/trust", wrapper.PutNodeSSHTrust)
	router.GET(baseURL+"/api/node/name/:nodename/system/disk", wrapper.GetNodeSystemDisk)
	router.GET(baseURL+"/api/node/name/:nodename/system/group", wrapper.GetNodeSystemGroup)
	router.GET(baseURL+"/api/node/name/:nodename/system/hardware", wrapper.GetNodeSystemHardware)
	router.GET(baseURL+"/api/node/name/:nodename/system/ipaddress", wrapper.GetNodeSystemIPAddress)
	router.GET(baseURL+"/api/node/name/:nodename/system/package", wrapper.GetNodeSystemPackage)
	router.GET(baseURL+"/api/node/name/:nodename/system/patch", wrapper.GetNodeSystemPatch)
	router.GET(baseURL+"/api/node/name/:nodename/system/property", wrapper.GetNodeSystemProperty)
	router.GET(baseURL+"/api/node/name/:nodename/system/san/initiator", wrapper.GetNodeSystemSANInitiator)
	router.GET(baseURL+"/api/node/name/:nodename/system/san/path", wrapper.GetNodeSystemSANPath)
	router.GET(baseURL+"/api/node/name/:nodename/system/user", wrapper.GetNodeSystemUser)
	router.GET(baseURL+"/api/object", wrapper.GetObjects)
	router.GET(baseURL+"/api/object/path", wrapper.GetObjectPaths)
	router.POST(baseURL+"/api/object/path/:namespace/svc/:name/disable", wrapper.PostSvcDisable)
	router.POST(baseURL+"/api/object/path/:namespace/svc/:name/enable", wrapper.PostSvcEnable)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name", wrapper.GetObject)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/abort", wrapper.PostObjectActionAbort)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/delete", wrapper.PostObjectActionDelete)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/freeze", wrapper.PostObjectActionFreeze)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/giveback", wrapper.PostObjectActionGiveback)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/provision", wrapper.PostObjectActionProvision)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/purge", wrapper.PostObjectActionPurge)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/restart", wrapper.PostObjectActionRestart)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/start", wrapper.PostObjectActionStart)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/stop", wrapper.PostObjectActionStop)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/switch", wrapper.PostObjectActionSwitch)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/unfreeze", wrapper.PostObjectActionUnfreeze)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/action/unprovision", wrapper.PostObjectActionUnprovision)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/config", wrapper.GetObjectConfig)
	router.PATCH(baseURL+"/api/object/path/:namespace/:kind/:name/config", wrapper.PatchObjectConfig)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/config/file", wrapper.GetObjectConfigFile)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/config/file", wrapper.PostObjectConfigFile)
	router.PUT(baseURL+"/api/object/path/:namespace/:kind/:name/config/file", wrapper.PutObjectConfigFile)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/config/keywords", wrapper.GetObjectConfigKeywords)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/data", wrapper.GetObjectData)
	router.PATCH(baseURL+"/api/object/path/:namespace/:kind/:name/data", wrapper.PatchObjectData)
	router.DELETE(baseURL+"/api/object/path/:namespace/:kind/:name/data/key", wrapper.DeleteObjectDataKey)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/data/key", wrapper.GetObjectDataKey)
	router.POST(baseURL+"/api/object/path/:namespace/:kind/:name/data/key", wrapper.PostObjectDataKey)
	router.PUT(baseURL+"/api/object/path/:namespace/:kind/:name/data/key", wrapper.PutObjectDataKey)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/data/keys", wrapper.GetObjectDataKeys)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/resource/info", wrapper.GetObjectResourceInfo)
	router.GET(baseURL+"/api/object/path/:namespace/:kind/:name/schedule", wrapper.GetObjectSchedule)
	router.GET(baseURL+"/api/openapi", wrapper.GetSwagger)
	router.GET(baseURL+"/api/pool", wrapper.GetPools)
	router.GET(baseURL+"/api/pool/volume", wrapper.GetPoolVolumes)
	router.GET(baseURL+"/api/relay/message", wrapper.GetRelayMessage)
	router.POST(baseURL+"/api/relay/message", wrapper.PostRelayMessage)
	router.GET(baseURL+"/api/relay/status", wrapper.GetRelayStatus)
	router.GET(baseURL+"/api/resource", wrapper.GetResources)

}

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

	"H4sIAAAAAAAC/+y9+3IbN9I4+ioo7Vfl5DsUJdnObuJTqS3FihN9cWytJO/W2cifDM40SaxmgAmAocSk",
	"VHVe47zeeZJf4TYXEhjOkJQsS/NPHHFwaTS6G41GX/7ciViaMQpUip1Xf+5kmOMUJHD919HpD0enIFjO",
	"I3iHU1C/xSAiTjJJGN15tRPzUYy4bYKoajPYIerL7znw+c5gR//2asd+4vB7TjjEO68kz2GwI6IppFiN",
	"K+eZaickJ3Syc3s7qM/OYjg+WjV/xCiFSH1ClMWwS+IQNCyGS/21EYCcYzPP4rQpvkGx++qfovK5nANu",
	"cJol6vM3YmfgmfLHGVD5GkdTD66FxFwiOQUEqhUaA8QoF4RO9I8JliAkyrCQpoFAY85S/S1SIyI5xRKl",
	"WEZT/aPIICJjAjG6IjRGmMYowSNIxDCwJD1KbT0xjHGeyJ1XY5wIKBY0YiwBTMsVvSGJBL68pIQIidjY",
	"Lci08k9efCxnJxJSsTyoaYngJuMgBGH0FfpNrfDjbwO9vu9nOMnh43//NoyxxDc3N/aHC7VX5Q69H/0H",
	"InkmsczFhyzGEuJBhuX0+zFjy3tX/IA5x3O98rckJdK35pRIpGFHEcupDCxYt/NTz8FgZ8x4iuXOqx1C",
	"5V9flvAQKmEC3ADAJqsQn7DJttCOkQfxFYTXsT8cDmvYFiT+/jv8Ley/hL/ujqKD57svX8Bfd799ER/s",
	"juFgP/7mxV9fAP5bO8yzyRuWJOzaQxz6d8MwbCJCqza9PeKhStpv2eQtoeDBBYeMaV4lAtE8HQFXyNas",
	"mej/sAkCKjkBEdx9qr8tAVDdYCWTRYYjeK8nxskyJNQ1aZDL7nuTLFQCuGEWFgMSkEAkWZUAhg3yNyAY",
	"6fMB/uN7yA+88vEEy+ny9EyzahcAFCM3HkclQPHoYHANo/8OwhNGy9pwrQWHCLO5BUSNLpBkSIAS9mwi",
	"0JjxBlBEG8avDF5n6Vl0MEBiFj1vxbSnkOD56yQXErjvqNfnmPmMSIwKvUWtTx9nCZPqA6P6T66GCx1k",
	"ZhijAbRWSQY7N7sTtmvHKCF1sCsWoV4tScFD7deNAHeDdNSkNHinkDLpAe54jPQIqBBagIQ+9RSAGhph",
	"fgQ+U7gXKEqIgX+IjsdIn/2IcUSZonUZGKkyBKQjiGOIzeghXuAG4BVCWK/tgwDuR71dndZuDHZ/z0HT",
	"0BSbZXHGJJpwTDXg2DRLQQg8gVKDKpWlXAA3gKMMc0m0ukmokKqvXWcxyzNRNgqtM3fAt9jEBh53O8UQ",
	"oVGSx4CIIyiRMSoAKXVHgAyi29Cdh99XMG+dMSycCmISh2VjobR3kI6uT0BCjsVfDgYk8wrIU5ZAA/Jw",
	"RhBnSeiUtJ88qPkvDuOdVzt/2SvvUXummdhTc3pF3Zldchg7DikBeCqfm0iGUHUu/AyYyxFg6a5wekQr",
	"rttez5rWeYQhZbQ+TTn9L4TGgVmVVr72rHrccpq3REigwO92kbVZysk3mTS0bYVy1zCw09za6DHqduhl",
	"DTsdi6FpGW1OnjoNn1cObK0gSmblZkVEIsmG6NPlJy2gPyUswsmUCfkJcRgDRzK7oO70NPdXDhGQGdSk",
	"+XDh6lYME1jvPxQ3HSbJWYJnRip4mcx8DS/wMJLq0MZJgoBGONOnAKYRiIFeTszoM4mwaaXAVSAVjRAZ",
	"6xMTiyuIlR6mBGBCIiIh0Wei57BzoCtJ8i6saig1Qwk1NMLRlVL1hGRcHWdGBDVaaJoJU0//mtEx4WkI",
	"b5H9vOLgdoNxY2DxjsQX7CfhYY4gARney1h/bqPNntcQKKw5STJkhhigayKnLJdoxBVypajfYyUWV3/J",
	"6TWmEuJWeq9bABF4lMApSxK1a8GFmGaX3LVriR5OZj47gJiya8RoMkdXML9mPLaqGhEoNl0C1i330X8O",
	"D+FGvmxivh/pLLhXQGdtNuqQIqAzwhlNlTI6w5wozJjrjXTKj9oPpXKnmMYCwQ1Eud7QiFEJN7K+eb/+",
	"P/88PP0+nc9w0mXrfpzhJMcSggty38Oi5Ai0vAMawQCJiGVGY40YnYHVpO0GIY6vkbahNMuIN4xHQYjG",
	"jEfQknR+4gDynKTAchkab6LaXErbyGsh9Fk864pjbaIKAMdpBlww2oBhUmnSfCDpg0Tzt1KUy27oegoU",
	"2Z0idIKwQ/gQnYHUP9WaWyng9vZ7fcvgIHNOBcLoBxyjU3vEAeeMD5vY4ReY187ersbzBc4wmr5kXFON",
	"M8uvml2smH41R7aat/n2YACpwabFUgi2q+t2kDnu0TpIymZQ53ygs+E6Uvst4NjIVa8Rz3xtx2e/YiHD",
	"Q6Xm60plZFnNqFy9iZIuS5pJXXfZQC35lc3gnAVXwGawK1k7FUNpo+6W5DM1hwyOKCFXgD7R3w6ev/j4",
	"aYA+0f9W/03nxvasRXsOn9qaJYPwvc/8D0P6PK1JayfWYzSaF+qE2gOWNbweFR8D99znTfx8wliyjnaY",
	"MZZsrByeOtPHGYlDpFCYRy7FwiNc8ayR5yRuWqN7GHxDksDTpJL26g5j1jomCVQpGYkp5mZTcPmAaNQa",
	"c9GoW4uUaBBGeuj7h/6sxB1i4+H23jw9qzs1eFxeHCexgZQoxSaDSIKWb3CTMQE1+GOzfoWOoG2lmzG0",
	"AmvDPq98YrVjnAGW4XuY/uhVKg6W3r3qp4kZtzZR1MC4Is8yxhW6lrRhfamZ2Dddx8dB60y0AfeeQRMq",
	"ZLfjjmVgQbYyEmKEBbrI9/dfRFfX+l/4zfxJaAw35peP5heWmT/NX1p0mh/MLQixzMjb79H/9T3a/X75",
	"SAUsvx/znEjR5VBtcS1vhYXyRFy4nlesuaO5Pi7V2Nu8tLdYpMQS3tNkHlynanCp7mYtFYizfKToIzSc",
	"+dqKHc/xJDSMxJOWYwQVgbY6wAcqGlghpy2ZoXqhN4pQcaU3muC2r/S3Sowak7sG5/n+vvpH3zip3h+c",
	"KZrRfLn3H2HEUTsr5AlnowRSM0t9ne9/UbA833+5jIJ3DL22s98Odl7eDzyVG5CZ9eA+Zv1AcS6njJM/",
	"IDbTvriPad8wPiJxDNTM+fI+5nzHJHrDcmrX+e19zOmutMU1Xc383X3M/JrRcUIiM+XBvWzqDyyeI8kY",
	"SjCf6Jecb+6HdY6pBE5xgs7Me+mPnDNu5r+XhZ+ZuyL6QPEMkwSPEvPYYbuqkQ/5iEiOJePGQ0o7D3Kl",
	"bkhixJ4ofm+Cwva+HezkPPG+NV4DmUxlwAOm1Fd/0wMM3LRFv4+FfDZ+CmpIbT8/lpAuQ+1ekQNC3ndc",
	"VWGomjwaZxatXxFLYD2mE/3xLRFyeSXdBtdbcGWf6oDmqVqN/lpZR2DRZibb3bvqXE4PowiEOGdXQJdh",
	"xfrjJdxkasxLLGt3wRhL2JXEb0yyXaUbuBnU5YkWRgiBf0zHbBnuFOSUxXV0O+SxDKi+/4ywIJG6mHyz",
	"/50iUGOp8KB1eXvtGEvzGgeMS/NpaRQiRG4sSSv2zbQbVIb7uNjGrTCEl1MYcxDTwL5y83WtjXV9G3bW",
	"C1EBCk6S9+OdV7+t4IAF2rwdrG5fW/Ttx9vBzmuc4RFJiJy3Fik+yeHDcjm0X2LFWK6U9RXwPGy+MIOP",
	"MFNYPck7FsOvqt3i0uwzvx5jYOBdvdD2MmwBfA8blS02EJWL4DUiUs+zUnBaxJjpvSgxz+flEbvcgqUp",
	"kepisrwqcRlNMZ1AHLg31mVB0dgHyNG7s1OIGPfKIiz8XkKOMpc+hA9ZmfgO+nVO34EFzAzaQHZH787+",
	"zSi0poMSFR5KOzr94egwSVhUBA7UkbWOIDRSvtkyWjd7GafElFDG/ejMGG+jUelmbqDBTu3UJAFCOf3h",
	"SPsHTMKSqljKaC79D1NVIMIb53E7Wrr6Fp+RMfHYaz16djDkN8+0BWdaNLG2Xe2s/Ww6+svBs4qlrzQI",
	"qK6+jaq7CLU/gky/s3wk5kJCWqjES1pSHHMv2yxsZ0j3Ud1t42V8fly8BNRXg8zHERinyfcZ0LN/vkax",
	"boQS10q4RWjHTxhc0OspiaaICOeGSEYJaLTrBykbu3J4cjy8oMs49O9pAZPl93JnplJmu4SCDG/PiU+f",
	"ymqaVJAdQjTv3T/PG7/DIF7EX4G2V+Ydmkh0jYWJFYg46NiTC+ps0BAjTFFuY1LQtX4DkAJFOedApUG9",
	"Qjmmsf5AYuMhtSC4i+E6iSMLzxoibLXI0pB7SdyutsOsC5tXX21tGbXRNbAOEv9uS/wLePQ8Jc1EC/k2",
	"6KIRDuywDZBsoNNURggqNdVZNtdoFmbscAHXj7O+D3Zw3ydB/oAWjG3ffe1Ag+K1U/VusYi18e3VIEyT",
	"zmN6xyLiynMMwyyzYTRrM2rKYvCbazhMCKPtwT/V7X3Qu80rNZ9QrFtQPxzszIDGrM1dWJGtw4ydu+jt",
	"1luolm6RXuIg4mr9m5reMh8XulHv6namgbNDNS2rA2E6kAOUuYncKoAJoGpb0qpwm9zqld4MuwGRGLB8",
	"a9dfxOellGJ1HTa0xIiPWvTXTeilAlIYa1siGh3x7IBdCnrR74JFE62lIReFIoQSLqX6QCjWT55L2/gm",
	"gZvQLSvFN/Vg4X2fwEwJrbV67pWqmE/Mi3LR7pvBqsNUjTzQUBQD+LD0E2d55tlOnyLuO4HasaAW60E+",
	"1DCsz4ZmCR56Ksf9XDxYQNCeR0qgPRyoP27AgBV4QvjaEvf9jHl8jTl0MlRVmdT3vTgGlq/eIU2qncXK",
	"qhtVAErDVeFkH3xOcotdn4YLdHm2pTb656LkKhDt6a0Guoee3fcNSLoOWAP6tkXYzkx1ytTd9NQeJSER",
	"2tVeuCw4fUAcnxzGMQfhee/F5YclQhkneBJDxiHC0muOrsPzJsGTo7K5dgmSY+/IKY4Cv5urz5p8qYYd",
	"FEtaWoAFyE7TwKAFvtbn0BLlHhqrj/+5eLQGRXsOqgPv4dKiwQZsugCbD4dH1Vk2Z9Rj6yvoOYEKla0R",
	"YtvfKnj6tk2JdYRv0/FX2/x20NIJw3V0lufbhlUdanv4YRRB5n11ss/bl92l0Jnp6RFGlTGbEB7SiHGW",
	"eUVBNIXoSuRp4CNJYm5ektsHwsc88z22DXRQm18yws2q7alo+yUxXOLCk7k9eLSSomLZjsajKQjJrQm2",
	"CaL3laZaCeIugVh7WIKaU5bgCFKg8jJjCYnmKx2ZXPsT01w/iDC/dSrjcLmMQE8zwrh9zF++FrlwAXfs",
	"ERPFf1Ijumablxmg3NQlmlZN4zzpIOjObI+lQUuDWsQy6LZJSza4sAlOSIXXqZ/8jffx6jWYZpUlsIwl",
	"bLKSBs5du208FSh5UZEOFVlgGHxgQ1QXCMlLXYNq5HyVwwZO93fM4yH8CiFWqa5KHW5XSxRXkLbwsOF2",
	"aEmGWjlc7KkRp0O7DZWvuyR1b42GfXcmRE7z0TBi6R7LgIpZtMfSF3uzF3sR47DnxtI4dnJ6A12oGM5z",
	"jFdHX1cTKo7QDfxYqoB00FOq4Pt0Ift9E1WoBlgDCtspQivd/gpk4mxdSVnd8PD4dmMXbLSd34sW1lc+",
	"B6mRGhdY6mcLCl9FiVjqPUnYCCeXJnTLC2mtxaWJCRSrx7rsLgEHO0RcTvFlUsSzLstwIlZ9zjjoDE+x",
	"v4VOy9G03mqDtRZRF76XJty/4xilkC7V2Ca19X21vbFNLgwhLmPrYLSMk4rqtLSpW9MzKheCZUWjpq+3",
	"1M+bXupN3NI6u7fxwV3nqAauCLFWlcgXWGKBfMPE6qGgEEXUsO9w6sFgI2EvcF5dUagNUmoahVxqqwo4",
	"Ctq6LhCKHtCBB+2DB6LQNU5H/m16+pTzLLHPmLM/gHaVtDVBuZhEt/5k5JoiIkwmO2IjUm1mvSkWOiJx",
	"BFD4BKE41/kt8AUtndtidk0VSChiMyhCn1OsVHiqYxsz4ITFwwuqfZB0GrylrwhoLAbV1H5iyvIkRiNA",
	"ObUupIMLimmMCtCvSZKoBgKkAkuv03gkeQ4JLOSlTnXcVW5Xkqm1IxqFB5x06JBxNiOKX83GrYiuKZpu",
	"U5Q3kCLPKVW4aO15YdrryAbvbREn4L8Ab37D0txt2dYxaZWZlumgssHlzi3JvuoO1SWhw45bWG0VbcXg",
	"mQsu2pIUtNlNjmBMqCYJ/9UIJwQL6GhfiTCNiVph134m51DgvasQVuFv7xse0kyLc7gJjZAp+dLR5uZ7",
	"WKicAO7p2ufuRKfAiR8WdzlqDwjLGgxKli4tgy7LvZI9vPaTiGU6DM//FcKmLBnCtfqhE6aXjLLOwlFJ",
	"VmKhrFKRBaG++eW2lCS1SEA1Ei5pY+Du4TWcuvUMCmYpd7dGIpVF+K50Xo5sf8X2M7SHVpYabnCvD8Ds",
	"ueD7Z938ycOO65deLkWWhqQqVjHVqCi+X2I/GdpkFlvzCtWJLFq4by14hTowFiB2463AS+ftXEE5m9PL",
	"KirZFm0sjC5mkcKZTjUUjfWBDOqXXChZQYX5LVL/fAw8GNkfKU4JnQx/MRCsfySbcVxK/9eMSs6SH1js",
	"8fFOYAZJPa8dUfrToFheDKN8ooWP/vkacx08oiO4BztjLLUCk2GqY0KpugauxLGZdYWSUoK+42oTNLmg",
	"2QZrOqC9A3nNuMe5WC+04wE+5gBB44M77chkeGzyV4Q9xEugVnmCr5oj6E+cC4hbj9MYnuagVWPiica7",
	"woOdosH73OL++MTD/tlK9+2TBUw1+gW4mdx2Nwnc4HseX21aOvV5oGTO9Fo8lZh8Ug74Rtx0E7klSj3k",
	"WXzcQOQuwOURuvVZNje+L+1dh0iLBj5aJxCzzYats10Nm7WFrVqxUdvaJstO6ziKqL6dnUS0r09XBxGd",
	"jrHBOUR9f4COIRUEeVCclOkl22H5ddGlwaFjythVB2IrBv+ZMS9Bm5JcTWajZQqsmO0uJxxHcGmMd4sK",
	"uCQpDIsqZ7rjzWWGOU4SCARip4ReauvNZQrpZRbJVc3ENc7C7TJ+BfNVp8PJqY1v4oDjedu1cPgPI7Tb",
	"+kWWENnkGCLEtAXAZ2c/a4gXqNV4DRgCKTa2YbcW9sOHfC+mFxDlR8XCYouluT1p5qfXVe6pM9YYIAZ+",
	"GUrnQ6iAKOdBSwafNXSWZRrqhn1cQHsFoMr0tbnKkZuXrZnUI0p0evFuSq8p0dfRfatVzIMDp5ijIQJC",
	"11X0prYp5c5CxRT9u36NmEJxcdD5eCvVA9vKvreqi1fsVaLoW4ZB1oLvfacUDRZoKooz2WVV8wXqpV1P",
	"gYMts6jXr983dDktzHVNJ0InulqQNwlk5i/PZQbwoVKyes0GJDA187VG79nhO10tbZUdr5BDFUclV/ur",
	"2IUg7aztyqMVH5965Ub9XGloHADdDvGQtaYk8qD+vVywryAJ1VETo5eqCjtWfQT9c32IxXoBzWp72J6l",
	"V7OBal2gNrDxW1SqOzkF+Sx/wYFDzj5d/XnWcZG4exea+3V/eaLeJ5/TlaTp2dOSeNApY2KzTi5n4cvI",
	"qg08PDnWLYvEkWu/hS/lnvQd9qrfwlY25A9Yw41jYrPMBRawetZWLnVsBjxhOG6VxMvsj9mNOqYLfNQf",
	"2Sfap3nB56kyZYhAhNMZ24v9upeB14KtxK4gdMyGv25mz3fjaASZOs6H7rLSLiWT6fSa6cDIDX2Tuod4",
	"mC1aGYShYXxj2m4Uv9HdEWYLIRrFEIUwbzWCzpu+mTPOekEFl0X6+EtTtrsaFv9iZVi8c3mxe7sYDFB6",
	"tPiiABZwtejnUnP4X4LTm+tria0txUfjyXpc8rEcYwtDMF8Ad7Gw1l78OFuM5mkmE9uuGivTHHKjGi3p",
	"Dk1dbCX5w+XXoXJ1tbAPF96x4tg2eDuyFy9M561xf2gtmp0EYoumipJaNm3d8gyiti1nbVt+EG1X/0/9",
	"tNqypZPmJVG/KaT6Qu54/bu7sOHJhMPE1Oxg40rNCiM4THI3UXlwLgRKSm60NKB76n6bU/vhYzVBXtF4",
	"SZ0xMK5/n68QoOdyVxl93Xu9GWKTm30JRPsrawVwz+3efN3gRlwFKYi2Ld2KKwhcArZjTEx4+KIQfXur",
	"ZsnaG54aiuc7DtFd+JXTKcGxIcT/NGGqdwvx+hKr/HE5Y6aNsK2U+5+mPrniHC8q+Yj+9uJvLw++ff5y",
	"f7A6rnQpI632Gwr6Rryv68Cllw6t+uhMsTZ3mvsxl16RVLNr/COH3Pem6TOWdHnZXDKeLLLb4vi+NZ/g",
	"6ApPPPoS5tE09AYjcZJAvHzfxf777oITiet/uHiF0y8x52qEJkcdQSZdnAsGOzPgwv8kF7Bg2vYDg4PC",
	"E6G6cANGA0LXPwvdjngkenXsz5WuowJD+5OqCrhHiNvPGxyFNajCmNuSV+IJloY5PFcMP2cUlqB1OCFP",
	"RwGHeg7mIteCts0glS51gg4uM5ixtnzodkjGcazDwzCdmDyXKZuZ/1l4QiwXsHHa24H7P69IYG2KerhQ",
	"+9AzZxUNXSiygjwvzctouomUUCTop3Q5/cwSwq6sI7LC0kFG041kQwGPF19u9C3IhQVL1YISQWFnMUDP",
	"9EWFjQYVZhsHn07jbTSNwU7CcIzwbGIfXAVi3Fhe7eAiYsY7IeOAtSl/SsZ+FWXBJrZ0sVyCzFmPyhI1",
	"kqTaH5kyulv5y94gYxj7J7bK34IbhKt+QbqGHG3iNNwiM8lUIbJTHYqgk6upGht4y2qfKyXsXrzOw5V1",
	"SW4x74wleQql/XJVXmyjTVknXKtDTQ1Z1nZ7YeQCT16f5pW2LEVeHYUPY14vEvX7JmKnAMQnddzYm9/M",
	"1VD/1AhsTiHRnjuIuGQ8m2IayjoQyr0USpzUmrj9FzbrwF1JpFNC2HCdKxHTnR4sQgNUYb5uSBtV0AIU",
	"UplnG3QipLNtn3A28SdiJOIyw1wSnLR5c1/TETf8Bh920W2qqqCWprSWsn6Mqx3qiYZ19XXWWEJZnMes",
	"Yr2aNHUQGkyOalmF3YYwegpGD1j2mmQ8gsAT78pRz66J9zYTg5CE4tV54lLi4hwPfK54M2jx+FydzHYK",
	"YeQUEjz/FYTwmi0iU/SqhU+ILY9ldtJ1Cx7qqZgED/uWnpUlZAvzmdErY3mXXnmHWqhow66BI/fqo10K",
	"K8+DMRoTLmStKvE33qzerqanhxKkfbNerBQ+zVNMd5WuiUe2RD6mtsq5qZIdIclMygkWmRIzkXOOvKCZ",
	"mbGWzaHujZMHajL/fH5+4nJIRCwG9NVvp29e/+35i4OPA2TrtKO/fo0mQMFgYTQ3czJOJoQi47+rawn5",
	"oUM+4KpaGJEJ+HAipozLwSJqRJ6mmM8XBkdq3CFCxxKd/fz+w9ujC/ru/TkyV2jtEVoFTLIwmAMENxFk",
	"8oKqJWU5z5gAXYFe+weRP8yufAXDyXCAckHoRHVVt98ZIFsT9oJSmDBJdNv/GwkA5EHri+HLr71btsTT",
	"0rxaF1VVDc781K0Jbh6ICeymgJu8DQEfcBmI5q/F9R5UhYb64bm6wDkTivrhRYMwc/GarhKMAcdN3uQi",
	"6dCwgV3AIbKiUnwWT9jqUjooRlUE+LQv+30T3asGmE/zqs6xBaNA3dWkLi6EKZY8KJ5qEePIZR5BFUeN",
	"peu3zoOz9HAree43tNlKOZ3q+UxclYW1K/20qK7UytWtodhO4Qxmr4cGaN9GPDzF4TJYlK8x1y5XC9mm",
	"BYC302DMvFXQB120moWEYsW8wb0yLmN+WXiH23WZ1HIuVs78O9kzsVif9QFvp0ZNiy0tVtVib7tU+6oT",
	"hed8qDTZ4IhYgtBzSizOtPkF3WXpWjeidzkxdMuoXk+mx3aRvYt5xW4bVhXyBSDiMiZC6chx0I/ZrqOh",
	"hTo849E8lB2puDd783Grj5exY9CSzVxM4MqdrSxhAd4acCUkbVOGLSBva6nD3LhvSOIjt1A+xFQLndai",
	"qOW92KRxS+0oDUdCCXMXVq6s1CswzPdjOmb+k8Ybsrtm8iAeKLq/ZlIhk9LCBN6GLxWLS+yOvAI5KxC4",
	"kchdBNIrcxfm2p7QXf/GVYjtJoA3eY8txPMGt7EqIGtsyoq938a+r9rzLe/3WzbpDONbNvmRSj5vRIVr",
	"E87+5CGC4k7SJpVT2aFpgdvKa752Ch6fsGoEOBQaWTm+O2gxzlh+e9vxrN16tuIAYJ6geSE7qfocUkwW",
	"kkKGbs1l20ExUdNuFFaLUDhfR12gXZxONdRm8SnI2j/MvE2ghyC2OtqyEWZKqDT+84XlhUwo4yAQThJb",
	"EV1yTIUO1kPGZUh4MxAXKaPrUxAakwhLXQAfy4W5BJpiGieFkRrpQUSeaMO1jssTNiuygStGdozpPAM+",
	"I4JxpGVDIC3y2KlMbTUlYRw9TZhefSVXMN81QeIZJlwYG1VM6AQp0uP6HUf9vyELhS7JkM2Xc6EwCLvX",
	"JAaERyyXxvbuMFGFvtzWxAXAe8KVJx1E98KFqL4qCUliSMAW1SdjRKRLTy05mUyAI4zsAJYEkMt1fUGr",
	"u0mZRHkW2ItqpukFGikx4Z42XDwHxAq7DL03gV7aWgg4RmyMDmeYJKX50HQcXtAftVsMIhS5GcvRY0af",
	"SSQkyxAOkXcA/A6BcyFRYqSBu64tJRi0CDCYx8k1ngudHzwbIJgBRXgs9VZo8LsB3+5WWwFTV8XxUMtC",
	"lg/Trk7MOjeiEGRCIUaS+WSixJOOfkvtEqg5QVfJjU0Sm9RW55U0LGUYqGSKWpLseoxgeYMt3nIsbuwq",
	"QlUM62etw802UmHzQu1Wop8ZuV56oppCwqMER1cJEdL9MNFeAdoPyWS23xns/IfpTwlg7a2qjgxs8GHf",
	"VMkfxnOWMW1n/j3HUtbSmlTM7JW06Mu+Bx3O9sxby7jhCtmUDGFJGTD+FFXnikz/N6AUuGwwHo9nIglu",
	"YWKyIxwX7WsFolv0PDeNl+Me3YCN9aKXpvcc0PaTC6WbMiGRUCeVy56DgMYZI1S/pXfJxoLRNeNJrI+9",
	"nJLf9dlZGQ+RGKgkYwK89ky/Q36nw+f7+y93D/YVHwzzUU5l/mr/4BX8dRS/xC9G33zz0itZrJxYEFvz",
	"rEjtUsytX6Drs4pIkLbpXoLFSxdRvv4F20c7i7dE72yfywHaB0yHUny+pXjOgsV2G1zC/QC3QPOWnkjd",
	"sOvgqQE1W8DICkRsd/3nhUBc4Fv9u+PchdReD0JCfbd7cKAllD2ph4LPXsUwe04PhhbeoVnF8KC7vML3",
	"JLFsXcSmUBdfenn/3UTdsXneLSvM6gyaFG66D2uREHiX1N8uaxlNgwUmLhfUf1+tiRKJLQNvii7OlL2Q",
	"uLKKyjoGyqX5FuKHumnngzWAu+//6q38wndlu5jfQDtwcN6V+X0bVT2ry+xelDeoAdjvm5xzNcB8B111",
	"js3N72cuM0ohvI2h+MB6FTxXvdrfh88CLqKnoOs6UakOD3dTrDtZ2fgmc58dIOMX+SzPng3Qs5hdU/Xv",
	"Nebq3+FwOKx4XuXqRq2alBUaqjFP6o4cj+ZINzP/qxvXUmnoj0vLMxWMg1Hzy+Ik5IFYNG1dm6o689Ys",
	"3/WKzK1psgqLZ9PPKxmYyvC6MSYJm+mLujeQrZLmqHShK7roNFs+CVGm3KnlK3i+//ybXaX2fHe+/9dX",
	"L/Zf7e//u1r8InweNwT6fhDgef7wGgJ8znbtnttNFYTQI7sC4Vjrej5fXJwHPQWxiQkLJbTrauKqJt4N",
	"xtnhFESGA56+HF9fFmC1UgzLHm5B1TmC2Fr75NLb7RG5xaif6/7qAGh/jBQgezZUfdvghCqBCaBqK3cw",
	"Uwct50TO1YmXGgBHWJDo0BK9BkgLXfVryddTKXWisBFgDty1Nn+9cfLgf/51bnUqM4T+ujjGbeXRxTqq",
	"71gZa16BkMnNWCS02Hk5PBi+NK8KQHUazZ0Xw/3h/k4la/Qezsie2Y1Xf+7YC6YxchJGj+OdVzs/gTzU",
	"DXSZV5yCBC6CKWXKJnuE/iMHPted3ykuuv04KIoE6dmf7+9bDzZp03/iLEuIiX/a+48warXZ7NWpOzk2",
	"XtkaVXUx//4XhYeX+wehUQqw9lQj3fZFm7YvVNtvzDKa26pGVUrSGKzQ0G8fbwd/1ujkt486nZ5+B/jN",
	"ssxHNYTZtFxO9xxBeC0DugiTTvyVy6mS2gavKAU5ZbFAIs/U8V2+LJqwFxO9sUwDuZwemxeCu9tDN0dg",
	"C28r6FAoWsAGhzEHYSzRzFeh6hRkzinCiMI1wlEEQiDJrmxJ2ighio0iTFEuAGGlHiqIGLcBMrrmbQwc",
	"EYqIFGjMkoRdEzpB3EQUiuEFPTdPPlqtsC9AtZmcoQanegr1/4wWj0V2CaatjoGakVg/8NnPep46WMhA",
	"5du3Eyb0xp1azHRl4VNmnnsXEZnim/qqnDvkAKX4hqR5ahKDo+cvp/plaefVzu9KGDj14tWO6X5Z8aMs",
	"aaRUpQ72U5/pxvfmptMZ2mlzod/VUMRBPwFOwcKpj24UJZikAbhcVkQfNFR4DFR3K9VyOT3UmDpX8DfJ",
	"tv028mr/LuXgy/2Xbdq+7CYzVdsXbdq+8MjXJXFqQ+20MDCsVqXjnWYBY9p8PvFyQS/osREUn6yk+IQK",
	"dlWixd5sdREJWxP7k+Q5fBrou25NuOja2TgRDI0AERoleU3SGMQO1ZznpeiBGHElFHQkKaQjiFUnvZhn",
	"mrmeGe5CZIxSLKOpgl8NmAt+QV0TW/CySWSd2/14vALLAOLOCo21AUpzIdV+YIrghhh/GRtqociGh6RW",
	"XkQ6eYAaM/bgpegSNMfjgnSrBGlKvltyXSRqRb3ulmlii+un7xAdjxFLiVR0zDj6pAPlPg0Qo8lc4Xzx",
	"qOaapcFSqm+lvDhay7UWhgcF/8Bjj/GRZ30hIfp8sY9iPBfNwKwiUkPk932O9SfYOifY6htCeaT9BNJz",
	"+qw41K6nDKek8fqXy+m/puwwPb5L5b9mXdrCHW6Tu1YdTVb+7pnnjz08ckZPrxZwqD4bkWX8fZz8tq6N",
	"xjmwln9TH7KnYNzEbF0o50xoan0gU8LDCgFGte+pzvIVOkNtZKOtnahBvsPN8+U0fTSc/nL/2zZtvzVt",
	"v2vT9rt7sxtY4guT85gDmGhrPz2/0d81wRk11igjjvgu6AnX1eCMO7QJWXfUK1AMkX7iEwOdTsOeQa6d",
	"QBJfATNWhwuqC4A4784RuMTkIxgzrlSiOapUNEQFzSt+0LrLXEhIBxe0Aue1yXiiv6eY4onSVksyb8c+",
	"BgU9/9T45zHzRE5XccUH26KBL05BSEW3QZ5QxK/PB5fwbr4Ok7h0/I5NEsAzd+kyeSCdU3SIeQzDWO5B",
	"HZhngARDOcVSAlXXQPdmhoi4oEB10CvCE0xoKzZzOO0Z7fEzWhm1HtI6LWkUz85rPT78qBQmU9anbZfj",
	"NAMuGO3W6xdj0RB3+8hhZ1n1zPH5qfaeqUu/aJk8dXWMHEECUknSyAqsnCot25nHrB1KOKuXdQcwxGnv",
	"0GhMEu1SuCC91IRboVEDo+hAbB/UIrp0ONPN75IyX7PUmFV6ulwp9fbGNrOC99nOWpGrOkWNHgPvczVS",
	"1AkNOu02iyTIXSE54LS+62X+SkKxNjYtGo58+22y+YLJvfz+1923WMjdX1lMxmQhp3DVGybTwTNqiP+9",
	"uIj/fHm7q/557v45N/+8qv3z1cXFUP3fweC726///u+//5cfwqcpFXPP2XqSB4hFG/h/YPH8HunkdolK",
	"W9zLn7t7+ZdmR/jC1LM9dz62EVauynjpVlA9Xe3AQzVwCwFWqFPrnqmczIB3OiGNb3P7Hu8NDu5D3zuC",
	"sQ5BM1Xo7/+E/czEOB3tceZSBASMVIybEHOKE/28ymgy19dlG45UHqZFdKfSCjlIpMd2VthzZt9dXf7U",
	"CITOh2odNMreBiT3LjrQs6oW5bOtMYuNSaLIZnBBd9HPrvep7nyWazP9YEji729ubjwtdKB2+b3pDr3Q",
	"8y4v0QtTndp5HvpF+qFK38HOza4jXvNmuMQCOgx5Deo/jGP7IqQfFeyTqGOFwunIPe3jjOiGS6/+vHiY",
	"1m+/EOuOzzhj8hliHD1TAD4zrgFF52XuUa0KJyYdAz+n0ZQzyvKym07fXDz3EoG0R4PLplAfw7DYFAs0",
	"AqAoy0cJEVP9Xns+JcJ+JwLpqHaI9eq+v8j3919EOCOX6k/9F7Ti/urc7Tj+fxihjs2Dcw9wHEN8Wfle",
	"fkNf6R3DNCZKUzb7WCxYd9Rv9FXz49du5mOTEaRh5mLgDrNfY4FwwgHHc4RrMxcTG7m1wbSYIp0p2SS1",
	"RnGudEhkEkrWptR6x9fNovF/TBD/giaxnDh8YZ2SKfwuYTfw9m5TGpV+xebx3/f+XsyzazulhL4FOlEy",
	"4nnrh/mVd64z4DOId3+Y+9OkVxelYz119hlL9JbDLa33V6rWktpkimjwEZsQYczxumUhySRDpibaAkuh",
	"FNKRNv13ksdv1eCrBXIdhjUlcn2QexbJtcnbyWSNm9VC2WxHUCzXBbFt7BfFesItyGI9pc0h5BG8epqH",
	"JXnf2rwpK0Wve7WqTrC5oFVNdyXbLaoNbkfQdpJ9d3IlKpMVea/lR3maFS+T1XRbeIZJomtOWFXQZLRq",
	"tikWCXm6XcXfufCo9y5zUIvL9RmYMOGyz51arWsLfJyBI8tEVIRhNry+ucDm7tt+guW0y46/YzHcz267",
	"NYWMKDqPhosCNhawQZnUjcY2HvhJvWUUtLJMPnsZltO9P4soyNu9P68IjW/NT7d7WbWOWMd76wdRhiW9",
	"Pv1Vq+KUMlvoppKKz3j4atlGtFah82dq/wfmtIUBImOTf81l5sPmDLWp+8qpwtLQWyCtu3FSMUchF9sZ",
	"G1WXXwiN27euBNu1Mel3YyIvIjzM9NqUKTIHkOUpx0s2MZ/SeMeJjr82qp0eTCl2NolmdaNjEus90/sL",
	"8XBJA7i9i8P70XBvw82lLT+XOsedcrPNbmnV+4J2bFJToDqxJXbJHFfx6pq6y2Pg1AUUeHhU7WM910XP",
	"VeudiRTkNeNXTRrVO9NErLoNVfOHlpe8EY6uFO27iQJXI1tfpaCP+4zxsAt8xDHYDvlL+75HshZbf3zy",
	"2Pf++ORp7b5NmL/qadzqPYMiczON7f0CxVhivdtN8RyKhKzlueMV/N7uVmomt/dP6SzQJFCniMWsDP69",
	"vOtcCuUkj5QbPYhXInDvT/eecds5YMuUT5XGurkYoeVVM09gMcRqLT2TxXD3GVJ61/f7fN3vQJ9RApiH",
	"6fO1+iyMUV6gryoRIgMdcQHx185/uRY5qG/ZIcJVJGcIVw9/V4S7yo9vf+epHxYBmog5rnt8NMmeI924",
	"lz297OlMZy2jP51wGa44BYtIyc1IsbUT5ql7Dz8j8d0ruPakjyLI+kiHjoSW5WK6h4UtmRJyjrApeXR4",
	"Do0LfzWXPNiY+9UgKCYiYjPg8+GK8+0kF9NDYcqRPHGqfEKUFhNxtSmhqTG60dmRmrUns6dDZkXY4SZ0",
	"luHoCk+gG6np+MOe1p4SrV1NPg+lXU16OnsadCYiTPeKdBQutXwjwRVmh2o3FOFoCsML+rpIbYHU2BS4",
	"yRxYJDa1r8KRTvAycakLR3MEijwrVQl1QJcbEdtp1FAuS53JN4EYR7bEHRoDljkHgUZYtbHvy87IZ8me",
	"Tmzmi7b2krMIl8siIHreeCK8MRccskZL8msjbEshbEJvip6rpO1ZMcW90dQbxqP+wv0Y6bVDDqO21p1K",
	"gp7evtOTmyG3RXVhZVKLqp5gvbxszOGj0BbsA+9WVYQ79YEvkN6nFWpP9CvTV2kaWDcv0JrSskxCNbiv",
	"BFl9tqt7Jsttpboyd7a2ia4+BzX3ebGerGBtnSFrmYp1ivcipNkGS+pAURZh42OnXSwHKNYBIjfzpkO8",
	"miDpPo/wPh3X4xPbgVxcd0FnfSavJ5bJq4No3V5OLx01vkJ2bpDIa121oU/99aWl/mpDvSZCzBm3OOg4",
	"wKbnCd2gGlymb/RaIagkONL6gK6hSGM0Y0kRcCaUfqB0h8gEMrr7vs2kAS7Bg7YqUKbr3+vQNJbzWqZt",
	"E+wo9HPc3FSvoUxeUMnn+pHO5vYus33bjAu26I1aRehR4kgvzC61d+G8L1JFe5akutGsmOZSF3sOEu3Z",
	"NJe6HnSRuyFMnjpRO0VCsqweunxBT5aIs0ag9UTwGXDC4kGdQCWfX1AvcWKBBGPUli4kvFI224Zv2lVa",
	"gJ6JC+rSlqifm0n5zKGoKy0fuYJH7UMv78W4ZpZ1Qvrr32asI1nWwDYeHlhLtm8s2RWtSw/X5FSSxJZR",
	"KPpfTjiO4NIwoOIPuMkIh3gFiyhUPGR7ck/yG5J8HpMGxebc5KzQEfCqpZO7eqrm/BVmZw71+FtQx5dD",
	"Vw1ACcwgGQaiVPXHelk6W65bx7fsDHauMTe19nR8XAyjfKJuoLxeZ725iqEBROQj+1ijjzI+ATkM108M",
	"1MpTv8V5Ui3IHZ474wBpVg8mM7CQsa5fRISrChaCxA7hryeoyxV6Cgp+/LKi9B/k9bkrn8ZU7MV5mjUn",
	"4aqmWz16d4b+YFQbLJWcDRgeDZsevTtTAzxsUf/u7N+MwiP2DepKFDrZYGNFdqBVUW2yE4omQvhRt7gH",
	"+0kXHfotSYls01BD/0YnX2zd/DWOpnBXyeIk3EizTV7bZxO5a+D618i1mWM6cl+qfkqtTTmWY6Yj9EkN",
	"8ElpPp/cJJ+alZ4yY/mWjCVtr5nFxL2N5TPQliCTJnMLmVCEKyn9YyKu2pGR6trT0NOgoWbpdLY92XTW",
	"S6YnRFUrLVpboqktmIt6kvoSSOqaZA3O3v8iGax52KmuPQ09MhpK9F0U+DZUcjfWGoLqre1633q5m7en",
	"ss9GZV0Uqy1Q2FlPX0+NvtqqWFuhrnvUs3ri+nzElbDJXsSo5CxpTs9Vp4+3bPLa9vqMVLL9JNPluvSw",
	"HsPoGUiElzgtYRP7UKjZq1XS6Z6iN6bojsS7PaL9bOSnc0VZ4nM01xPc3RMcH8V7OEmY2dbgk1inogET",
	"sA6dfBTbGE+UEso4onk60tGiNEYZ47JSoNDAUEZ0WvfPkNvy0ekPR4cl3A/6+bUO6lYepe7R37ehJEWY",
	"pJYCLzcgpzHIaIrGnKUIm0dZbEhrOSwOjTmepOE3e0c59xYjpyY7teHO90Npdmn902eQegfbKIzikje1",
	"pkjVWDs2JklT8pqHQJ13U42ovjqbMcJHp0erMKlOj/LMQqSvMnQP4pxCJLdVVEhcOb4ZM44w+qQmwXGK",
	"7DyfUMTSVG0z3ECUqzlWs4wG8HPwTMc+LIbjI9858Hjj8B46eWecpJjP75y87TzdyfvEAvgwFJaeUD8X",
	"oQqIGI3vg1SLmboT61kBZE+uT5hc1bU/HL38k7URGCdb2zh0YzOhwg/6jq9B7J1OW8cJt6xm2ab28b1Z",
	"6u+zzuQd11Y+lpD2tZU7GVQLtOwhMYt2Bp7fZ9oCv/x7NJ54fxfgHycXfEv84x5ZR4w13N5+YDb5ji0y",
	"6gYfNtZsNWkYVd/HxoGtM0wcJslZgmedsl/9ioXslPiinlyzfbdOrTsv4ywfCZAdOpzjSZfW7H4EYZ9L",
	"dCNpt10pFetUcmE5ZXPnrSmpTO8nK6vuL0dvz1t3pkmENIaQhkFF6Mv2dYwONcrW4N57LFn2ZDWNzjP0",
	"MuVJn9c64bewfiN+pj9xTbx8j/5lkiNhCZeMJnNUkBgiAkmew0DbL0uLZjElxDaxCxE2P0zcRowU8PSS",
	"pEuyPpN8/ZQlyQhHV3dYuOKtzn/6BK9Tipbf02TeX8F6kf5ZRfrKmKIJ0WlSMI0RBwF8ZnS6AiwRCYJi",
	"sCm1hEuSqKG/gnnI+2VBTp/ebyBIL6Wht2H1ArQXoNsQoE0BTUecZVZu6j0XVpAqqcrtL1NIipd6Jzad",
	"X7RXzLaXqfcY/tSL1F6k9iK1F6mbi9RcTPdc0bA9nXFywwK7C3aIsiKZGpynpkJJG4mai6lzPzo2mTD7",
	"x4WHxqE9163FdZ1y969h0L/vVBK9OtKrI7060qsjmwvGvOG94zT3vnQgicVVK6mY9y8TXRhcR5PxtEsP",
	"3qmIUC8470pwti9+Smeil7NPTs62K8Sji9isqYKuXcfmKUvcXiD2mmQv4bYj4dqk1ltXtvWX6/5y3YvE",
	"XiR+gSJR9YhH8zUkIyLanVD1RimL20vKMztlLzB7gdkLzF5gfkkCU+Zi9YOoT1iavi1lpJqlf97s4xye",
	"JI+1qmu71i2td8h6WNanX9kMOlmne1WjF4NPRAzOabRH6AREg9HqWH8vPapmmOv0jQJxiIDMyhxUatRZ",
	"1aF1TiOUZzGW5ls7F6yzOY3MnL12cqcSaC2B0suIJyYjcroqDPyDbbGuyuT692pTHwre8/3D4fsWweAf",
	"ykYPJBy8AlEvT/qw7juJ0u6vbr14/mziOUoA87BEfq0+I0wRcM44+upix/j0jzFJIL7Y0WmB4QanWQJf",
	"I7IQgugSQ2rJuyoGUU/1RHJ19nR+J/kyw9ms7iGTpsmGujcmCQSzGp+CzHlNt/HWsWApcvMP0fG4+EMp",
	"L9Sm4kxYhBP9ZYBiphSdm3mgqk3BYXquNwrAJ50Sl0US5K6QHHBaP7dMcN/Oq50RoSZBuZxnsPNqR0hO",
	"aKhqzmBnqtUXPfX7X3ffYiF3f2UxGROIa8PGWMKuJKnZAKmU1J1XO/97cRH/+fJ2V/3z3P1zbv55Vfvn",
	"q4uLofq/g8F3t1///d9//y8/hL0o+RJS70aMCpbAKi8WjMQUksQdroqmMaHASxOqSb6fMQGIKOHAWT6Z",
	"IoxyniA5xRJFmKIRIJYBNeZVjEacXQvgyGT1l3K+K6aYwycUJSRQH6t6WLug1td2DU/WtNrpevATB5Dn",
	"JAWWd9HfzwBLb4DDgUdh44CVOl2TSW8r5fseqLh4kGUNlkXLllg/YeHad2c6YxKFa5SwiWg+0d+yyRN0",
	"unjLlBLT8vqvGrMkYdctG78lFFpFE0m4kXswA+pXJVaUO+1LQXz5B3iRcqJR5w8X3DG3AVEc60AlYmP9",
	"py2yB7G5EmBhfzV4RyMWzwfomkjjt6Xa/P//7/8nUAoSx1hi9JW6chM6ZupSHiV5DLFTIIpB7AExROdT",
	"IlAhY9QlwxhXgSvFVfU0QIkMIq3TGqAUdlTjGXDzKxZWDTE6Bl3On7HiguK0isd4RelgqCyRsEHX0+7P",
	"LHd9L/qJszzz6CCDz35p0hCcAE9D0H0QwB+w9vQQ7ZNdK0J1lrou0c8qS0steQ+SeJSAE7OLD0ztxNNj",
	"zORzlxb/Kt56vefz2frVfsR5O/Oka7sJv5y5+Xpeac0rDmcPn0++kBv7XfOUxLK8ADg7Xl3v4ZBgSWaw",
	"q8byaRFNljb9pPxobfZtSolvWy29fUIVQF/uf9em7XdfJpNuakZTvHFPJrT7sFmtbqugfgDGrUdeuzRT",
	"sidEl1hcmZzNkiHVEOEkQVGS65z56oMYhon1RI28/Tq3X5b8ezD7vLk+rcZq2O6tKdC9xvqwCEdM96ZM",
	"yCuYi1bEI6Yoy0cJiZDqhlQ/JEzi4gyA6wdeyXOhXUNSRCgiUqAryq7ppeohtMW2idLOfv7ZAXT3xKZP",
	"lyzBZIHMWmpvPS0t0NIVzDuS0RXMUQxjYv0BtBwSYqp+9tMVkY6qcC6njJM/IL7UdLiasn6BeU9UXxxR",
	"6X3Xl9rcQ1bnTtosUJVQR5umnaAuc5I7wtCDfGZ95rHv5FxISPdiIq6CIuKfBK71VupWIT7WAx2ZFg9X",
	"G1EA9ppIV/KYuJe5ZvowzRoJ5Cfb5OFSiIawJ5GuJDLFPL7GHFZTiWspminlZzfgQyYWB2RPL13phWQ4",
	"jjkIsRWxcnxyaEd7yNRSQNmTS1dyyXB0hSctpItr2EguJ0Wjh0ssFsaeVLqTioymbQhFNVtBJqbJQyYS",
	"GU17EulMIlztupy3oBLXsplQylYPmFYskD25dCUXgekeoUQSLBlfTTNl00aiOTt8d1xp+YAt+Ifv1GQF",
	"sD0BrUNAzrmjmXYk5hOQYiXlqA35Eoimp5WutJJbV+JmOlGtVlCJ9kl+yCSiAOzpw0cfxo8ySAUKadov",
	"wLQTReyncRMIvLa8N407k4QiiPd6apzcLUEYCHuS0CRhaWCRKJrPkcprXqKIhI2dT67qJlCq7guETszL",
	"DNiStnCTcRA6rdKEzIC6DIs6gqeghEayMp5D65DWfZCU9Wt6lB5HTXRSc0wVs8h5pcYm835DlXnTQFPB",
	"9ZQlgMQsQowjwVLtnUKkKAInAhnAz2aRHWbdU6i7o+mdhmdvK4Vl704VIOKlIOoWpAy0mZJ/pNsgZDNK",
	"T8c9HW+VjmuxApVDPXDI3h/9PbSwF7P+Ywnpoz7FC3f34k8T1l78aaLZy8ZQa1yPXW9FdC7/Jh6xeim5",
	"ZTFo9sCm5dPNny458mgKQhoE/SOH/KEnKOwWE/Jtm7bfPsj4kfX4yCWGuwPGiiEBCe0568i071mrZ62e",
	"tZpZazlTfDNrvdko73vPWj1rfQ7WWpM5JmQGuqpia/b4yfXoGaRnkIfMIGtyhLfAQDNLnGya3L/niZ4n",
	"vqBDI8v5BNrV3yhspjq9rLnlVHLADC/oERFX+uO4YmFFU5bEKMYSD9EPcI05DFCl9gfKRY6TZG4HNGnt",
	"dOsLepLziQ6I1ibcmIFJdq1h1u1mrHwRzUVZKEzMolC+2hqz68X3jN4z+uNndA66TkP7k/DUdnj47NEm",
	"ZUxHx8kALjR3qAkJh9imsOsZtNdO1+LIjvx49oVwY88LPS+swQv1etmrWGH9Gtg9J/Sc8KA54ZrYYKaW",
	"vGDa91pagYpeSevZcWvsuLo68WGSsGuEc8lSLEmkC+GxGXDExtpsoXPyf2IFlcD3U/xpeEFNPzkF9HvO",
	"eJ6iGZOgq+fJqa7qpROBla1c6TwDGLqeAkWf7I/fKyL/VLXQcEAxTDiOIdYWGcp0hXWlQ+JRAm2sI5uW",
	"Te5P2p61vyADSed6xHV76BVAFizjdwe20QokHhNpvlA3eUND6RaKHvfSoJcGX4I0MHy72jPXlM582NzQ",
	"2t37xxlOciy7dDlOM+CC0W69foH5NeOxuFtOtbP0YWV37sWl6++Y6+pCOJF5HhSgzw+hjjUBUh+A6t8r",
	"SwcujjFY+9YTn6EmfIQ8aDDWpez7B4XSTnXiQd4x571maUqkfEwn4xPztNxu0WpMTSpZcwvGKIYsYXNd",
	"es4WjEFvGbuy117wjWM12LK6NRoTLqQug73wYYqV9luWDKjVqFlZFLsqUzYpr9EXuO4LXH+xp/kKm/MX",
	"xR19KZknVkrmjnkj97FG3nNGzxlPmjPW0i/dBbBLXhORZxnjEuLa9dFMu1qlK0wPj+S6yMmsXe2o4vKn",
	"r+IdepgUQPdiqjmCsc6hx+jnMdo8MSaMscSrOA8jIXkeyZxDXLDgFcy1DWeGkxyEe1JovFAdqbkeB8/9",
	"AnMN0h0XLMAS/wJznb3oSd5sNjI8HiJB6CSBXckxFfaxPGKp0lX0/7MxwnE8QNEU0wkgxl0oQ0G/wtkc",
	"rmC+qykdCcm4/ttfv6Q0ST58ar8rZxyFgyrprvbB+dL0v7t5IXt50AaGgwfKh93PHVebqkyT4H05wPqs",
	"0UZEDyv6uNB0LNlwgyJTD/Pc6TMy3cU5skIH0oeJpkVDfth4YThw0YjF85X6z5MgxTuzP39ZBoCHqzB5",
	"PZpec8Ba3FK41mROaFuBW5qFHzON34Ot7JEpSl+0QjPwVzd8bW4L2pdOc4W6RlAEN0RIQiddOSfvGadn",
	"nMfFOOvdBERzynPLT6IDby0qXuLpeqxaDDiTau98c+9k7jy99wgdszZvHa4DUh3K0vBl6v/Cu6XZ6npq",
	"xzlW8z5ZBqhi4eF7g35RXmldOUFtSZy3cypzbev0X3E3a8cDZ27KJ0v/DgM97d8V7WdAcUaawgXOrvFk",
	"ouvybLTNVvu1tR8edkpsh0NTBL6CroyxpAlXJ4wl6+hr+vahOne8sOjSSbYmyh2X4mMsWcWFX7DNVW9s",
	"fZ/3ZizJU1i13f/Urbaw6Xe9ewbQp7OHHBI830tBiHoV3qVdPFUNf7Xtum6j7vzOVkRrw7m6w2tT9ur4",
	"qHWPDwI4vQd9s4KKx0klmixW+AovUMRd5X5YhW0FIMImNCDGEguQNioB6VWgKWAuR4DlTsuEEatMSftP",
	"6qHNkUJdYgiJZR426/wEElmhIpxmrzvWA5MNlDGhE5cJ4VzHekwI3cuwENeMx6aDZGgMMprqGzNPjZMH",
	"5sZWK3Bq/qfYaj1N4NqgCerMwL+WIBOt5dEppEzehzQyy3nEx9YyFZo7f/ORZQPwNyyNuHqz1dHWpf0p",
	"ie+n8qJDQYgyJiBLY5Rx2h2UOUhojCyfPy2BZ0nr4+3t7e3/CQAA///yEdrcCYMCAA==",
}

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

	return buf.Bytes(), nil
}

var rawSpec = decodeSpecCached()

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

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

	return res
}

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

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