// 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/scsi/scan)
	PostNodeActionSCSIScan(ctx echo.Context, nodename InPathNodeName, params PostNodeActionSCSIScanParams) 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
}

// PostNodeActionSCSIScan converts echo context to params.
func (w *ServerInterfaceWrapper) PostNodeActionSCSIScan(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 PostNodeActionSCSIScanParams
	// ------------- 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 "hba" -------------

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

	// ------------- Optional query parameter "target" -------------

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

	// ------------- Optional query parameter "lun" -------------

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

	// Invoke the callback with all the unmarshaled arguments
	err = w.Handler.PostNodeActionSCSIScan(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/scsi/scan", wrapper.PostNodeActionSCSIScan)
	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+ioo7Vfl5DsUJdnObuJTqS3FihN9cWytZO/W2cifDM40SaxmgAmAocSk",
	"VHVe47zeeZJf4TYXEhjOkNTF0vwTRxxcGo3uRqPRlz93IpZmjAKVYufVnzsZ5jgFCVz/dXT6w9EpCJbz",
	"CN7hFNRvMYiIk0wSRnde7cR8FCNumyCq2gx2iPryew58vjPY0b+92rGfOPyeEw7xzivJcxjsiGgKKVbj",
	"ynmm2gnJCZ3s3NwM6rOzGI6PVs0fMUohUp8QZTHskjgEDYvhQn9tBCDn2MyzOG2Kr1HsvvqnqHwu54Br",
	"nGaJ+vyN2Bl4pvxxBlS+xtHUg2shMZdITgGBaoXGADHKBaET/WOCJQiJMiykaSDQmLNUf4vUiEhOsUQp",
	"ltFU/ygyiMiYQIwuCY0RpjFK8AgSMQwsSY9SW08MY5wncufVGCcCigWNGEsA03JFb0gigS8vKSFCIjZ2",
	"CzKt/JMXH8vZiYRULA9qWiK4zjgIQRh9hX5TK/z020Cv7/sZTnL49N+/DWMs8fX1tf3hXO1VuUPvR/+B",
	"SJ5JLHPxMYuxhHiQYTn9fszY8t4VP2DO8Vyv/C1JifStOSUSadhRxHIqAwvW7fzUczDYGTOeYrnzaodQ",
	"+deXJTyESpgANwCwySrEJ2yyLbRj5EF8BeF17A+Hwxq2BYm//w5/C/sv4a+7o+jg+e7LF/DX3W9fxAe7",
	"YzjYj7958dcXgP/WDvNs8oYlCbvyEIf+3TAMm4jQqk1vj3iokvZbNnlLKHhwwSFjmleJQDRPR8AVsjVr",
	"Jvo/bIKASk5ABHef6m9LAFQ3WMlkkeEI3uuJcbIMCXVNGuSy+94kC5UAbpiFxYAEJBBJViWAYYP8DQhG",
	"+nyA//ge8gOvfDzBcro8PdOs2gUAxciNx1EJUDw6GFzB6L+D8ITRsjZca8EhwmxuAVGjCyQZEqCEPZsI",
	"NGa8ARTRhvErg9dZehYdDJCYRc9bMe0pJHj+OsmFBO476vU5Zj4jEqNCb1Hr08dZwqT6wKj+k6vhQgeZ",
	"GcZoAK1VksHO9e6E7doxSkgd7IpFqFdLUvBQ+3UjwN0gHTUpDd4ppEx6gDseIz0CKoQWIKFPPQWghkaY",
	"H4HPFO4FihJi4B+i4zHSZz9iHFGmaF0GRqoMAekI4hhiM3qIF7gBeIUQ1mv7KID7UW9Xp7Ubg93fc9A0",
	"NMVmWZwxiSYcUw04Ns1SEAJPoNSgSmUpF8AN4CjDXBKtbhIqpOpr11nM8kyUjULrzB3wLTaxgcfdTjFE",
	"aJTkMSDiCEpkjApASt0RIIPoNnTn4fcVzFtnDAungpjEYdlYKO0dpKPrE5CQY/GXgwHJvALylCXQgDyc",
	"EcRZEjol7ScPav6Lw3jn1c5f9sp71J5pJvbUnF5Rd2aXHMaOQ0oAnsrnJpIhVJ0LPwPmcgRYuiucHtGK",
	"67bXs6Z1HmFIGa1PU07/C6FxYFalla89qx63nOYtERIo8NtdZG2WcvJNJg1tW6HcNQzsNLc2eoy6HXpZ",
	"w07HYmhaRpuTp07DHyoHtlYQJbNysyIikWRD9PnisxbQnxMW4WTKhPyMOIyBI5mdU3d6mvsrhwjIDGrS",
	"fLhwdSuGCaz3H4qbDpPkLMEzIxW8TGa+hhd4GEl1aOMkQUAjnOlTANMIxEAvJ2b0mUTYtFLgKpCKRoiM",
	"9YmJxSXESg9TAjAhEZGQ6DPRc9g50JUkeRdWNZSaoYQaGuHoUql6QjKujjMjghotNM2Eqad/zeiY8DSE",
	"t8h+XnFwu8G4MbB4R+IL9pPwMEeQgAzvZaw/t9FmP9QQKKw5STJkhhigKyKnLJdoxBVypajfYyUWl3/J",
	"6RWmEuJWeq9bABF4lMApSxK1a8GFmGYX3LVriR5OZj47gJiyK8RoMkeXML9iPLaqGhEoNl0C1i330X8O",
	"D+Favmxivh/pLLhXQGdtNuqQIqAzwhlNlTI6w5wozJjrjXTKj9oPpXKnmMYCwTVEud7QiFEJ17K+eb/+",
	"P/88PP0+nc9w0mXrfpzhJMcSggty38Oi5Ai0vAMawQCJiGVGY40YnYHVpO0GIY6vkLahNMuIN4xHQYjG",
	"jEfQknR+4gDyA0mB5TI03kS1uZC2kddC6LN41hXH2kQVAH7+4XAZYWdaH58jjKYjrPc8wlRLUQpXaJSw",
	"6BLFMCMRBM2Z0xH2E/A3+/sHL198u7///OWL5y9f7DfQ8XGaAReMNuw+qTRpPiz1Iadlj1Liy27oagoU",
	"WSoidIKwI4YhOgOpf6o1txLK0d33+gbEQeacCoTRDzhGp/b4Bc4ZHzax6i8wr+kFXQ37C1xrbiGScU3R",
	"7slg1exixfSrpUWreZtvNgaQGmxaZIZgu7xqB5njbK0fpWwGdakEdDZc50R5+/FdE98kbEIinKCcEumM",
	"lGvxUZKHHjkOmnb2LeDYHEneQc3XdiLqVyxkeKjUfF2pxy1raBWrBVGCeUmpq6t9G2h0v7IZfGDBFbAZ",
	"7ErWTjtTiry7YPqs9CFbLUrIJaDP9LeD5y8+fR6gz/S/1X/TuTHb61Mxh89tLbpB+N5n/jc1rYrUDjp3",
	"IsZoNC80MbUHLGt4eCs+BkwEz5uI8oSxZB3FOmMs2VivPnVWozMSh0ihsCxdiIX3y+JFKM9J3LRG96b6",
	"hiSBV111GKnrn1nrmCRQpWQkppibTcHl26vRCM0drW5oU5JLGOGmr276s5LGiI2H23su9qzu1OBxeXGc",
	"xAZSonTCDCIJWvzCdcYE1OCPzfoVOoJmqW525AqsDfu88nXajnEGWIavsPqjVx87WHoyrB92ZtzaRFED",
	"44o8yxhX6Fq6SOj74MQ+hzs+Dhq2og249wyaUCG7ncYsAwuylZEQIyzQeb6//yK6vNL/wm/mT0JjuDa/",
	"fDK/sMz8af7SotP8YC6QiGVG3n6P/q/v0e73yyc+YPn9mOdEii5nfguLRisslCfigmWjYggfzfVxqcbe",
	"pr2jxSIllvCeJvPgOlWDC3WtbalAnOUjRR+h4czXVuz4AU9Cw0g8aTsGn4Bs0t2kbrGeumb6Bm8++/vf",
	"/e3FN98efPvN/rffNvBaWFtpq6h8pKKBX3PakmOrBhujrRUmG6NNb9tkc6NkvXlS0eA8399X/2iLAtXb",
	"hjNF2Fp47P1HGJnZzsp8wtkogdTMUl/n+18ULM/3Xy6j4B1Dr+3sN4Odl3cDT+UWaWY9uItZP1Kcyynj",
	"5A+IzbQv7mLaN4yPSBwDNXO+vIs53zGJ3rCc2nV+exdzOrNAYYZRM393FzO/ZnSckMhMeXAnm/oDi+dI",
	"MoYSJRLVxN/cDescUwmc4gSdmffwHzln3Mx/Jws/Mxda9JHiGSYJHiXmMct2VSMf8hGRHEvGjQecdg7l",
	"SieSxIg9UfzeBIXtfTPYyXnifUu+AjKZyoCHU6lU/6YHGLhpi36fCvls/FDUkPp95FhCugy18xIICHnf",
	"cVWFoWo2apxZtH4lLoH1mJ/0x7dEyOWVdBtcb8GlfYoFmqdqNfprZR2BRZuZbHfvqnM5PYwiEOIDuwS6",
	"DCvWHy/gOlNjXmBZu7DGWMKuJH6DnO0q3cDNoC5PtDBCCPxjOmbLcKcgpyyuo9shj2VA9SVthAWJ1O3p",
	"m/3vFIEac4oHrcvba8dYmtc42FyYT0ujECFyY+5asW+m3aAy3KfFNm6FIbycwpiDmAb2lZuva22s69uw",
	"s16IClBwkrwf77z6bQUHLNDmzWB1+9qibz7dDHZe4wyPSELkvLVI8UkOH5bLof0SK8ZypayvgOdh84UZ",
	"fISZwupJ3rEYflXtFpdm3Tj0GAMD7+qFtpdhC+B72KhssYGoXASvEZF6npWC0yLGTO9FiXGPKI/Y5RYs",
	"TYlUF5PlVYmLaIrpBOLA5bYuC4rGPkCO3p2dQsS4VxZh4fcCc5S59CF8yMrEd9Cvc/oOLGBm0AayO3p3",
	"9m9GoTUdlKjwUNrR6Q9Hh0nCoiIwpI6sdQShkfLN5tu6bc44naaEMu5HZ8Z4G41KN3MDDXZqpyYJEMrp",
	"D0fa/2MSllTFUkZz6X/cqwIR3jiPW9nS1bf4jIwdyl7r0bODIb9+pi0j06KJNUBrZ/xn09FfDp5VzJGV",
	"Z6shv/ZtVN0FrP0RZPqd5SMxFxLSQiVe0pLimHvZZmE7Q7qP6m4bL+Pz0+IloL4aZD6OwDjFvs+Anv3z",
	"NYp1I5S4VsItQjv2wuCcXk1JNEVEODdTMkpAo12/mtnYpMOT4+E5Xcahf08LmCy/lzszlTLbJRRkeHtO",
	"fPpUVtOkguwQonnv/nl8OBwG8SL+CrS9Mm/5RKIrLEwsSMRBxxadU2cohxhhinIbc4Su9EOFFCjKOQcq",
	"DeoVyjGN9QcSGw+4BcFdDNdJHFl41hBhq0WWhtxL4na1HWZd2Lz6amvLqI2ugXWQ+Hdb4l/Ao+cpaSZa",
	"yLdBF41wYIdtgGQDnaYyQlCpqc6yuUazMGOHC7h+QfZ9sIP7PgnyB7RgbPs4bQcaFE+yqneLRayNb68G",
	"YZp0HtM7FhGXnmMYZpkNk1qbUVMWg99cw2FCGG0P/qlu74PebV6p+YRiGYP64WBnBjRmbe7CimwdZuzc",
	"RW+33kK1dIv0EgcRl+vf1PSW+bjQjXpbtzMNnB2qaVkdCNOBHKDMTeRWAUwAVduSVoVb7Fav9GbYDYjE",
	"gOVbu/4i7pdSitV12NASIz5q0V83oZcKSGGsbYlodES7A3YpqEm/CxZNtJaGXJSREEq4lOoDoVg/eS5t",
	"45sErkO3rBRf14PB930CMyW01uq5V6oWD83lC/Bg1WGqRh5oKIoBfFj6ibM882ynTxH3nUDtWFCL9SAf",
	"ahjWZ0OzBA89lePeFw8WELTnkRJoDwfqjxswYAWeEL62xH0/Yx5fYQ6dDFVVJvV9L46B5at3SJNqZ7Gy",
	"6kYVgNJwVQRRBJ+T3GLXp+ECXZ5tqY1+X5RcBaI9vdVA99Cz+74BSdcBa0DftgjbmalOmbqbntqjJCRC",
	"u9oLlwWnD4jjk8M45iA87724/LBEKOMET2LIOERYes3RdXjeJHhyVDbXLkFy7B05xVHgd3P1WZMv1bCD",
	"YklLC7AA2WkaGLTA1/ocWqLcQ2P18e+LR2tQtOegOvAeLi0abMCmC7D5cHhUnWVzRj22Do2eE6hQ2Roh",
	"tv2tgqdv25RYb/02HX+1zW8GLZ0wXEdneb5pWNWhtocfRhFk3lcn+7x90V0KnZmeHmFUGbMJ4SGNGGeZ",
	"VxREU4guRZ4GPpIk5uYluX2ig5hnvse2gQ5a9EtGuF61PRVtvySGC1y4W7cHj1ZSkCzb0Xg0BSG5NcE2",
	"QfS+0lQrQdwliGsPS1BzyhIcQQpUXmQsIdF8pSOTa39imusHEea3TmUcLpYR6GlGGLeP+cvXIhfT4I49",
	"YrI0nNSIrtnmZQYoN3WJplXTOE86CLoz22Np0NKgFrEMum3Skg0ubIITUuF16id/4yK9eg2mWWUJLGMJ",
	"m6ykgQ+u3TaeCpS8qEiHiiwwDD6wIcgLhOSlrkE1M0KVwwZO93fM4yH8CiFWqa5KHW5XSxRXkLbwsOF2",
	"aEmGWjlc7KkRp0O7DZWvuyR1b42GfXcmRE7z0TBi6R7LgIpZtMfSF3uzF3sR47DnxtI4dnJ6A12oGM5z",
	"jFdHX1cTKo7QDfxYqoB00FOq4Pt0Ift9E1WoBlgDCtspQivd/gpk4mxdSVnd8PD4dmMXbLSd34sW1lc+",
	"B6mRGhdY6mcLCl9FiVjqPUnYCCcXJr7MC2mtxYUJXBSrx7roLgEHO0RcTPFFUgTdLstwIlZ9zjjoDF6x",
	"v4VOu9K03mqDtRZRF74XJp1DxzFKIV2qsU1q6/tqe2ObXBhCXMTWwWgZJxXVaWlTt6ZnVC4Ey4pGTV9v",
	"qZ83vdSb4Kp1dm/jg7vOUQ1cEWKtKpEvsMQC+YaJ1UNBIYqoYd/h1IPBRsJe4Ly6olAbpNQ0CrnUVhVw",
	"FLR1XSAUPaADD9oHD0Sha5wOT9z09CnnWWKfMWd/AO0qaWuCcjFJcv3JyDVFRJhMhcSGzdrMiVMsdNjk",
	"CKDwCUJxrnOE4HNaOrfF7IoqkFDEZlDEZ6dYqfBUB2BmwAmLh+dU+yDpNIdLXxHQWAyqqRvFlOVJjEaA",
	"cmpdSAfnFNMYFaBfkSRRDYSJSdTrNB5JnkMCC3mhU1l3lduVZHntiEbhAScdOmSczYjiV7NxK6Jriqbb",
	"FOUNpMhzShUuWntemPY6ssF7W8QJ+C/Am9+wNHdbtnVMWmWmZTqobHC5c0uyr7pDdUnosOMWVltFWzF4",
	"5oKLtiQFbYaYIxgTqknCfzXCCcECOtpXIkxjolbYtZ/JKRV47yqEVfjb+4aHNNPiA1yHRsiUfOloc/M9",
	"LFROAPd07XN3olPgxA+Luxy1B4RlDQYlS5eWQZflXskeXvtJxDIdhuf/CmFTlgzhWv3QCdNLRlln4ahk",
	"VLFQVqnIglDf/HJbSpJaJKAaCZe0MXD38BpO3XoGBbOUu1sjkcoifFc6L0e2v2L7GdpDK0sNN7jXB2D2",
	"XPD9s27+5GHH9Usvl2ZMQ1IVq5hqVBTfL7CfDG3Gja15hepsGy3ctxa8Qh0YCxC78VbgpfN2rqCczell",
	"FZVsizYWRhezSOFM50OKxvpABvVLLpSsoML8Fql/PgUejOyPFKeEToa/GAjWP5LNOK5kw2tGJWfJDyz2",
	"+HgnMIOknreQKP1pUCwvhlE+0cJH/3yFuQ4e0RHcg50xllqByTDVMaFUXQNX4tjMukJJKUHfcbUnmlzQ",
	"bIM1HdDegbxi3ONcrBfa8QAfc4Cg8cGddmQyPDb5K8Ie4iVQqzzBV80R9CfOBcStx2kMT3PQqjHxRONd",
	"4cFO0eB9bnF/fOJh/2yl+/bJAqYa/QLcTG67mwRu8D2PrzYtnfo8UDJnei2eSkzSKwd8I266idwSpR7y",
	"LD5uIHIX4PII3fosmxvfl/auQ6RFAx+tE4jZZsPW2a6GzdrCVq3YqG1tk2WndRxFVN/OTiLa16erg4jO",
	"GdngHKK+P0DHkAqCPChOyhyY7bD8uujS4NAxZeyyA7EVg//MmJegTcm1JrPRMgVWzHYXE44juDDGu0UF",
	"XJIUhkUVO93x+iLDHCcJBAKxU0IvtPXmIoX0IovkqmbiCmfhdhm/hPmq0+Hk1MY3ccDxvO1aOPyHEdpt",
	"/SJLiGxyDBFi2gLgs7OfNcQL1Gq8BgyBFBvbsFsL++FDvhfTC4jyo2JhscXS3J4089PrKvfUGWsMEAO/",
	"CKXzIVRAlPOgJYPPGjrLMs14wz4uoL0CUGX62lzlyM3L1kzqESU6fXw3pdeUYOzovtUq5sGBU8zREAGh",
	"62Z6U9uUcmehIo7+Xb9GTKG4OOikwZXqkG1l31vVxSv2KlH0LcMga8H3vlOKBgtwFcW37LKq+QL10q6m",
	"wMGW0dTr1+8bulwa5rpmF6ETXQ3Km6ky85dfMwP4UClZvSYHEpia+Vqj9+zwna6Gt8qOV8ihiqOSq+1W",
	"7EKQdtZ25dGKj0+9cqPeVxoaB0C3QzxkrSmJPKh/LxdkLEhCddTE6KWqwo5VH0H/XB9isR5Es9oetmfp",
	"1WygWheoDWz8FpXqTk5BPstfcOCQs09Xf551XCRu34Xmbt1fnqj3yX26kjQ9e1oSDzplTGzWyeUsfBlZ",
	"tYGHJ8e6ZZE4cu238KXck77DXvVb2MqG/AFruHFMbJa5wAJWz9rKpY7NgCcMx62SeJn9MbtRx3SBj/oj",
	"+0T7NC/4PFWmDBGIcDpje7Ff9zLwWrCV2BWEjtnw183s+W4cjSBTp/vQXVbapWQynV4zHRi5oW9S9xAP",
	"s0UrgzA0jG9M243iN7o7wmwhRKMYohDmrUbQyd03c8ZZL6jgoshxf2HKslfD4l+sDIt3Li92bxeDAUqP",
	"Fl8UwAKuFv1cag7/S3B6c30tsbWl+Gg8WY9LPpVjbGEI5gvgLhbW2osfZ4vRPM1kYttVY2WaQ25UoyXd",
	"oanLR9PycPl1qFxdLezDhXesOLYN3o7sxQvTeWvcH1qLZieB2KKpoqSWTVu3PIOobctZ25YfRdvV/1M/",
	"rbZs6aR5SdRvCqm+kDte/+4ubHgy4TAxhUXYuFJYwwgOk9xNVB6cC4GSkmstDeieut/m1H74VE2QVzRe",
	"UmcMjOvf5ysE6LncVUZf915vhtjkZl8C0f7KWgHcc7s3Xze4EVdBCqJtS7fiCgKXgO0YExMe/sRZutpb",
	"NUvW3vDUUDzfcYjuwq+cTgmODSH+pwlTvV2I15dY5Y/LGTNthG0pWsQ09ckV53hRyUf0txd/e3nw7fOX",
	"+4PVcaVLGWm131DQN+J9XQcuvXRo1UdnirW509yPufSKpJpd4x855L43TZ+xpMvL5pLxZJHdFsf3rfkE",
	"R5d44tGXMI+moTcYiZME4uX7LvbfdxecSFz/w8UrnH6J+aBGaHLUEWTSxblgsDMDLvxPcgELpm0/MDgo",
	"PBGqCzdgNCB0/bPQ7YhHolfHvq90HRUY2p9UVcA9Qtx+3uAorEEVxtyWvBJPsDTM4bli+DmjsAStwwm6",
	"fGogX6a5yLWgbTNIpUudoIPLDGasLR+6HZJxHOvwMEwnJs9lymbmfxaeEMsFbJz2duD+zysSWJuiHi7U",
	"PvTMWUVDF4qsIM9L8zKabiIlFAn6KV1O71lC2JV1RFZYOshoupFsKODx4suNvgW5sGCpWlAiKOwsBuiZ",
	"vqiw0aDCbOPg02m8jaYx2EkYjhGeTeyDq0CMG8urHVxEzHgnZBywNuVPydivoizYxJYulkuQOetRWaJG",
	"klT7I1NGdyt/2RtkDGP/xFb5W3CDcNUvSNeQo02chltkJpkqRHaqQxF0cjWlbQNvWe1zpYTdi9d5uLIu",
	"yS3mnbEkT6G0X67Ki220KeuEa3WoqSHL2m4vjFzgyevTvNKWpciro/BhzOtFon7fROwUgPikjht785u5",
	"GuqfGoHNKSTacwcRF4xnU0xDWQdCuZdCiZNaE7f/wmYduCuJdEoIG65zJWK604NFaIAqzNcNaaMKWoBC",
	"KvNsg06EdLbtE84m/kSMRFxkmEuCkzZv7ms64obf4MMuuk1VFdTSlNZS1o9xtUM90bCuvs4aSyiL85hV",
	"rFeTpg5Cg8lRLauw2xBGT8HoActek4xHEHjiXTnq2RXx3mZiEJJQvDpPXEpcnOOBzxVvBi0en6uT2U4h",
	"jJxCgue/ghBes0Vkil618Amx5bHMTrpuwUM9FZPgYd/Ss7KEbGE+M3plLO/SK+9QCxVt2BVw5F59tEth",
	"5XkwRmPChaxVJf7Gm9Xb1fT0UIK0b9aL5cyneYrprtI18cjW8cfUlmI3pbwjJJlJOcEiU2Imcs6R5zQz",
	"M9ayOdS9cfJATeafP3w4cTkkIhYD+uq30zev//b8xcGnAbLF5NFfv0YToGCwMJqbORknE0KR8d/VtYT8",
	"0CEfcFUtjMgEfDgRU8blYBE1Ik9TzOcLgyM17hChY4nOfn7/8e3ROX33/gMyV2jtEVoFTLIwmAME1xFk",
	"8pyqJWU5z5gAXSZf+weRP8yufAXDyXCAckHoRHVVt98ZIFsT9pxSmDBJdNv/GwkA5EHri+HLr71btsTT",
	"0rxaF1VVDc781K0Jbh6ICeymgJu8DQEfcBmI5q/F9R5UhYb64bm6wDkTivrhRYMwc/GarhKMAcdN3uQi",
	"6dCwgV3AIbKiUtyLJ2x1KR0UoyoCfNqX/b6J7lUDzKd5VefYglGg7mpSFxfCFEseFE+1iHHkMo+giqPG",
	"0vVb58FZeriVPPcb2mylnE71fCauysLalX5aVFdq5erWUGyncAaz10MDtG8jHp7icBEsyteYa5erhWzT",
	"AsDbaTBm3irogy5azUJCsWLe4F4ZlzG/LLzF7bpIajkXK2f+reyZWKzP+oC3U6OmxZYWq2qxt12qfdWJ",
	"wnM+VJpscEQsQeg5JRZn2vyC7rJ0rRvRu5wYumVUryfTY7vI3sW8YjcNqwr5AhBxEROhdOQ46Mds19HQ",
	"Qh2e8Wgeyo5U3Ju9+bjVx4vYMWjJZi4mcOXOVpawAG8NuBKStinDFpC3tdRhbtw3JPGRWygfYqqFTmtR",
	"1PJebNK4pXaUhiOhhLkLK1dW6hUY5vsxHTP/SeMN2V0zeRAPFN1fM6mQSWlhAm/Dl4rFJXZHXoGcFQjc",
	"SOQuAumVuQtzbU/orn/jKsR2E8CbvMcW4nmD21gVkDU2ZcXeb2PfV+35lvf7LZt0hvEtm/xIJZ83osK1",
	"CWd/8hBBcSdpk8qp7NC0wG3lNV87BY9PWDUCHAqNrBzfHbQYZyy/uel41m49W3EAME/QvJCdVH0OKSYL",
	"SSFDt+ay7aCYqGk3CqtFKJyvoy7QLk6nGmqz+BRk7R9m3ibQQxBbHW3ZCDMlVBr/+cLyQiaUcRAIJ4mt",
	"iC45pkIH6yHjMiS8GYiLlNH1KQiNSYSlLoCP5cJcAk0xjZPCSI30ICJPtOFax+UJmxXZwBUjO8Z0ngGf",
	"EcE40rIhkBZ57FSmtpqSMI6eJkyvvpJLmO+aIPEMEy6MjSomdIIU6XH9jqP+35CFQpdkyObLOVcYhN0r",
	"EgPCI5ZLY3t3mKhCX25r4gLgPeHKkw6ie+FCVF+VhCQxJGCL6pMxItKlp5acTCbAEUZ2AEsCyOW6PqfV",
	"3aRMojwL7EU10/QCjZSYcE8bLp4DYoVdht6bQC9tLQQcIzZGhzNMktJ8aDoOz+mP2i0GEYrcjOXoMaPP",
	"JBKSZQiHyDsAfofAuZAoMdLAXdeWEgxaBBjM4+QKz4XOD54NEMyAIjyWeis0+N2Ab3errYCpq+J4qGUh",
	"y4dpVydmnRtRCDKhECPJfDJR4klHv6V2CdScoKvkxiaJTWqr80oaljIMVDJFLUl2PUawvMEWbzkWN3YV",
	"oSqG9bPW4WYbqbB5oXYr0c+MXC89UU0h4VGCo8uECOl+mGivAO2HZDLb7wx2/sP0pwSw9lZVRwY2+LBv",
	"quQP4znLmLYz/55jKWtpTSpm9kpa9GXfgw5ne+atZdxwhWxKhrCkDBh/iqpzRab/G1AKXDYYj8czkQS3",
	"MDHZEY6L9rUC0S16fjCNl+Me3YCN9aKXpvcc0PaTC6WbMiGRUCeVy56DgMYZI1S/pXfJxoLRFeNJrI+9",
	"nJLf9dlZGQ+RGKgkYwK89ky/Q36nw+f7+y93D/YVHwzzUU5l/mr/4BX8dRS/xC9G33zz0itZrJxYEFvz",
	"rEjtUsytX6Drs4pIkLbpXoLFSxdRvv4F20c7i7dE72z35QDtA6ZDKT7fUjxnwWK7DS7hfoBboHlLT6Ru",
	"2HXw1ICaLWBkBSK2u/4PhUBc4Fv9u+PchdReD0JCfbd7cKAllD2ph4LPXsUwe04PhhbeoVnF8KC7vMJ3",
	"JLFsXcSmUBdfenn/3UTdsXneLSvM6gyaFK67D2uREHiX1N8uahlNgwUmLhbUf1+tiRKJLQNvii7OlL2Q",
	"uLKKyjoGyqX5FuKHumnngzWAu+//6q38wndlu5jfQDtwcN6W+X0bVT2ry+xelDeoAdjvm5xzNcB8B111",
	"js3N72cuM0ohvI2h+MB6FTxXvdrfh88CLqKnoOs6UakOD3dTrDtZ2fgmc58dIOMX+SzPng3Qs5hdUfXv",
	"Febq3+FwOKx4XuXqRq2alBUaqjFP6o4cj+ZINzP/qxvXUmnoj0vLMxWMg1Hzy+Ik5IFYNG1dm6o689Ys",
	"3/WKzK1psgqLZ9M/VDIwleF1Y0wSNtMXdW8gWyXNUelCV3TRabZ8EqJMuVPLV/B8//k3u0rt+e7D/l9f",
	"vdh/tb//72rxi/B53BDo+1GA5/nDawjwOdu1e243VRBCj+wKhGOt6/l8cXEe9BTEJiYslNCuq4mrmng3",
	"GGeHUxAZDnj6cnx1UYDVSjEse7gFVecIYmvtk0tvt0fkFqPe1/3VAdD+GClA9myo+rbBCVUCE0DVVu5g",
	"pg5azomcqxMvNQCOsCDRoSV6DZAWuurXkq+nUupEYSPAHLhrbf564+TB//zrg9WpzBD66+IYN5VHF+uo",
	"vmNlrHkFQiY3Y5HQYufl8GD40rwqANVpNHdeDPeH+zuVrNF7OCN7Zjde/bljL5jGyEkYPY53Xu38BPJQ",
	"N9BlXnEKErgIppQpm+wR+o8c+Fx3fqe46ObToCgSpGd/vr9vPdikTf+JsywhJv5p7z/CqNVms1en7uTY",
	"eGVrVNXF/PtfFB5e7h+ERinA2lONdNsXbdq+UG2/MctobqsaVSlJY7BCQ799uhn8WaOT3z7pdHr6HeA3",
	"yzKf1BBm03I53XME4bUM6CJMOvFXLqdKahu8ohTklMUCiTxTx3f5smjCXkz0xjIN5HJ6bF4Ibm8P3RyB",
	"LbypoEOhaAEbHMYchLFEM1+FqlOQOacIIwpXCEcRCIEku7QlaaOEKDaKMEW5AISVeqggYtwGyOiatzFw",
	"RCgiUqAxSxJ2RegEcRNRKIbn9IN58tFqhX0Bqs3kDDU41VOo/2e0eCyySzBtdQzUjMT6gc9+1vPUwUIG",
	"Kt++nTChN+7UYqYrC58y89y7iMgUX9dX5dwhByjF1yTNU5MYHD1/OdUvSzuvdn5XwsCpF692TPeLih9l",
	"SSOlKnWwn/pMN743N53O0E6bC/2uhiIO+glwChZOfXSjKMEkDcDlsiL6oKHCY6C6XamWy+mhxtQHBX+T",
	"bNtvI6/2b1MOvtx/2abty24yU7V90abtC498XRKnNtROCwPDalU63mkWMKbN/YmXc3pOj42g+GwlxWdU",
	"sKsSLfZmq4tI2JrYnyXP4fNA33VrwkXXzsaJYGgEiNAoyWuSxiB2qOb8UIoeiBFXQkFHkkI6glh10ot5",
	"ppnrmeEuRMYoxTKaKvjVgLng59Q1sQUvm0TWB7sfj1dgGUDcWaGxNkBpLqTaD0wRXBPjL2NDLRTZ8JDU",
	"yotIJw9QY8YevBRdguZ4XJBulSBNyXdLrotErajX3TJNbHH99B2i4zFiKZGKjhlHn3Wg3OcBYjSZK5wv",
	"HtVcszRYSvWtlBdHa7nWwvCg4B947DE+8qwvJESfL/ZRjOeiGZhVRGqI/K7Psf4EW+cEW31DKI+0n0B6",
	"Tp8Vh9rVlOGUNF7/cjn915Qdpse3qfzXrEtbuMNtcteqo8nK3z3z/LGHR87o6dUCDtVnI7KMv4+T39a1",
	"0TgH1vJv6kP2FIybmK0L5ZwJTa0PZEp4WCHAqPY91Vm+QmeojWy0tRM1yLe4eb6cpo+G01/uf9um7bem",
	"7Xdt2n53Z3YDS3xhch5zABNt7afnN/q7JjijxhplxBHfOT3huhqccYc2IeuOegWKIdJPfGKg02nYM8i1",
	"E0jiS2DG6nBOdQEQ5905ApeYfARjxpVKNEeVioaooHnFD1p3mQsJ6eCcVuC8MhlP9PcUUzxR2mpJ5u3Y",
	"x6Cg558a/zxmnsjpKq74aFs08MUpCKnoNsgTivj1+eAS3s3XYRKXjt+xSQJ45i5dJg+kc4oOMY9hGMs9",
	"qAPzDJBgKKdYSqDqGujezBAR5xSoDnpFeIIJbcVmDqc9oz1+Riuj1kNapyWN4tl5rceHH5XCZMr6tO1y",
	"nGbABaPdev1iLBridh857Cyrnjnun2rvmLr0i5bJU1fHyBEkIJUkjazAyqnSsp15zNqhhLN6WXcAQ5z2",
	"Do3GJNEuhQvSS024FRo1MIoOxPZRLaJLhzPd/DYp8zVLjVmlp8uVUm9vbDMreJ/trBW5qlPU6DHwPlcj",
	"RZ3QoNNus0iC3BWSA07ru17mryQUa2PTouHIt98mmy+Y3Mvvf919i4Xc/ZXFZEwWcgpXvWEyHTyjhvjf",
	"8/P4z5c3u+qf5+6fD+afV7V/vjo/H6r/Oxh8d/P13//99//yQ/g0pWLuOVtP8gCxaAP/Dyye3yGd3CxR",
	"aYt7+XN3L//S7AhfmHq2587HNsLKVRkv3Qqqp6sdeKgGbiHACnVq3TOVkxnwTiek8W1u3+O9wcFd6HtH",
	"MNYhaKYK/d2fsPdMjNPRHmcuRUDASMW4CTGnONHPq4wmc31dtuFI5WFaRHcqrZCDRHpsZ4X9wOy7q8uf",
	"GoHQ+VCtg0bZ24Dk3kUHelbVony2NWaxMUkU2QzO6S762fU+1Z3Pcm2mHwxJ/P319bWnhQ7ULr833aEX",
	"et7mJXphqlM7z0O/SD9U6TvYud51xGveDJdYQIchr0H9h3FsX4T0o4J9EnWsUDgduad9nBHdcOnVnxcP",
	"0/rtF2Ld8RlnTD5DjKNnCsBnxjWg6LzMPapV4cSkY+DnNJpyRlledtPpm4vnXiKQ9mhw2RTqYxgWm2KB",
	"RgAUZfkoIWKq32s/TImw34lAOqodYr2678/z/f0XEc7IhfpT/wWtuL86dzuO/x9GqGPz4NwDHMcQX1S+",
	"l9/QV3rHMI2J0pTNPhYL1h31G33V/Pi1m/nYZARpmLkYuMPsV1ggnHDA8Rzh2szFxEZubTAtpkhnSjZJ",
	"rVGcKx0SmYSStSm13vF1s2j8HxPEv6BJLCcOX1inZAq/S9gNvL3blEalX7F5/Pe9vxfz7NpOKaFvgU6U",
	"jHje+mF+5Z3rDPgM4t0f5v406dVF6VhPnX3GEr3lcEvr/ZWqtaQ2mSIafMQmRBhzvG5ZSDLJkKmJtsBS",
	"KIV0pE3/neTxWzX4aoFch2FNiVwf5I5Fcm3ydjJZ42a1UDbbERTLdUFsG/tFsZ5wC7JYT2lzCHkEr57m",
	"YUnetzZvykrR616tqhNsLmhV013Jdotqg9sRtJ1k361cicpkRd5r+VGeZsXLZDXdFp5hkuiaE1YVNBmt",
	"mm2KRUKeblfxdy486r3LHNTicn0GJky47HOrVuvaAh9n4MgyERVhmA2vby6wufu2n2A57bLj71gMd7Pb",
	"bk0hI4rOo+GigI0FbFAmdaOxjQd+Um8ZBa0sk89ehuV0788iCvJm789LQuMb89PNXlatI9bx3vpRlGFJ",
	"r09/1ao4pcwWuqmk4jMevlq2Ea1V6PyZ2v+BOW1hgMjY5F9zmfmwOUNt6r5yqrA09BZI626cVMxRyMV2",
	"xkbV5RdC4/atK8F2bUz63ZjIiwgPM702ZYrMAWR5yvGSTcynNN5xouOvjWqnB1OKnU2iWd3omMR6z/T+",
	"Qjxc0gBubuPwfjTc23BzacvPpc5xq9xss1ta9b6gHZvUFKhObIldMsdVvLqm7vIYOHUBBR4eVftYz3XR",
	"c9V6ZyIFecX4ZZNG9c40EatuQ9X8oeUlb4SjS0X7bqLA1cjWVyno4y5jPOwCH3EMtkP+0r7vkazF1h+f",
	"PPa9Pz55WrtvE+avehq3es+gyNxMY3u/QDGWWO92UzyHIiFree54Bb+zu5Waye39UzoLNAnUKWIxK4N/",
	"L287l0I5ySPlRg/ilQjc+9O9Z9x0Dtgy5VOlsW4uRmh51cwTWAyxWkvPZDHcfoaU3vX9Ll/3O9BnlADm",
	"Yfp8rT4LY5QX6KtKhMhAR1xA/LXzX65FDupbdohwFckZwtXD3xbhrvLj29956odFgCZijuseH02y50g3",
	"7mVPL3s601nL6E8nXIYrTsEiUnIzUmzthHnq3sPPSHz7Cq496aMIsj7SoSOhZbmY7mFhS6aEnCNsSh4d",
	"nkPjwl/NJQ825n41CIqJiNgM+Hy44nw7ycX0UJhyJE+cKp8QpcVEXG5KaGqMbnR2pGbtyezpkFkRdrgJ",
	"nWU4usQT6EZqOv6wp7WnRGuXk/uhtMtJT2dPg85EhOlekY7CpZZvJLjC7FDthiIcTWF4Tl8XqS2QGpsC",
	"N5kDi8Sm9lU40gleJi514WiOQJFnpSqhDuhyI2I7jRrKZakz+SYQ48iWuENjwDLnINAIqzb2fdkZ+SzZ",
	"04nNfNHWXnIW4XJZBETPG0+FNwTRDBLmCUUaxochEkQXidOxjwIwj6aIjXUgjtIqRQsye312rMa7L/Jq",
	"3e3nHw47tHal+lp3ePvxXU/rd07rc8Eha3w1eW0Ui1LhMGFmRc9VmsVZMcWdEfgbxqPeuPQY6bVDvq62",
	"lsxKMqreltmTmyG3RdV4ZQKXqk5sPRptfO2j0IytM8NW1eFbjfcokN6n0GpP9CtTtWkaWDcH1prSsky4",
	"NrirZHB9Zrc7JsttpXUz9om2Sd3ug5r7HHBPVrC2zga3TMW6nEERvm8Dg3VQNIuw8SfV7sQDFOtgqOt5",
	"0yFeTQZ2l0d4n3ru8YntQN6526CzPmvdE8ta10G0bi9/nc6QsEJ2bpC0bl21oU9z96WluWtDvSYa0hm3",
	"OOiY16anON2gGkipb/RaIagk89L6gK4XSmM0Y0kRXCmUfqB0h8gE7br7vs0aAy6ZibYqUCb1Sap4heW8",
	"llXeBPYK/fQ8N5WaKJPnVPK5fpC2eezLzPY2u4gt8KRWEXoZOdILs0vt3ZXvilTRniWpbjQrprnUhc3D",
	"b2XTXOra50WekjB56qIEFAnJsnqY/jk9WSLOGoHWix5kwAmLB3UClXx+Tr3EiQUSjFFbppPwSol4+8xn",
	"V2kBeibOqUvRo35uJuUzh6KutHzkinu1DzO+E+OaWdYJ6a9/m7GOZFkD23h4YC3ZvrFkV7QuPVyTU0kS",
	"WzKk6H8x4TiCC8OAij/gOiMc4hUsolDxkO3JPclvSPJ5TBoUmw8mP4vO9qBaOrmrp2rO1WJ25lCPvwV1",
	"fDlM2wCUwAySQEC2+1ZJTGYr0+tQrp3BzhXmpqykDgWNYZRP1AVUsYq3aH0oXLx4WxL5yDzZCJ1jw64+",
	"UDA0UBxS/RbnSbUCfRiCjAOkWT160mCGjHXBLiJcGbxhABI7hL+Apq7P6amg+enLSkvxIO/QXZk1pmIv",
	"ztOsOetcNb/w0bsz9Aej2mqphG3A+mh49ejdmRrgYcv7d2f/ZhQesYNQV6LQ2TWDFKHu8UCr8tqk4xRN",
	"hPCjbnEHRpQuivRbkpJWbmsa+jc622jr5q9xNIXbyo4o4VqabfIaQJvIXQPXP0muzRzTkftSdVZqbc+x",
	"HDMdoc9qgM9K/fnsJvncrPmUKfq3ZDFpe9csJu4NLfdAW4JMmmwuZEIRrtSwiIm4bEdGqmtPQ0+Dhpql",
	"09n2ZNNZL5meEFWtNGttiaa2YDPqSepLIKkrkjV4fP+LZLDmYae69jT0yGgo0XdR4NtQyd1Yawiqt7br",
	"Xevlbt6eyu6NyrooVlugsLOevp4afbVVsbZCXXeoZ/XEdX/ElbDJXsSo5CxpzkdXp4+3bPLa9rpHKtl+",
	"VvVyXXpYj2H0DCTCS5yWsIl5LTTs1SrLek/RG1N0R+LdHtHeG/np5GiW+BzN9QR3+wTHR/EeThJmtjX4",
	"JNapSsYErFcnH8U20BOlhDKOaJ6OdMgojVHGuKxU5DQwlGGd1gc05Lt8dPrD0WEJ94N+fq2DupVHqTt0",
	"+m2owRImqaXoyw3IaQwymqIxZynC5lEWG9Jajo1DY44nafjN3lHOnQXKqclObczz3VCaXVr/9Bmk3sE2",
	"KgG5bGWtKVI11t6NSdKURuchUOftlN+qr86mjfDR6dEqTKrTozyzEOnLat2BOKcQyW1V0RKXjm/GjCOM",
	"PqtJcJwiO89nFLE0VdsM1xDlao7VLKMBvA+e6diHxXB85DsHHm8w3kMn74yTFPP5rZO3nac7eZ9YAB+G",
	"wtIT6n0RqoCI0fguSLWYqTuxnhVA9uT6hMlVXfvDIcw/WRuBcbK1jUM3NhMv/KDv+BrE3um0dbBwy/Kt",
	"bYp935ml/i4Lq95yMfFjCWlfTLyTQbVAyx4Ss2hn4Pl9pi3wy79H44n3dwH+cXLBt8Q/7pF1xFjD7e0H",
	"ZjPw2Kq6bvBhY5Fik4tR9X1sHNg6zcRhkpwleNYpBdavWMhO2S/WzHB82ql152Wc5SPRKSXyBzzp0prd",
	"jSDsE4puJO22K6VinU8uLKdsAr01JZXp/WRl1d0l6u1569Y0iZDGENIwqAh92b6O0aEo3xrce4c1+p6s",
	"ptF5hl6mPOnzWmf9FtZvxM/0J66Jl+/Rv0yGJCzhgtFkjgoSQ0QgyXMYaPtladEspoTYZnchwiaJiduI",
	"kQKeXpJ0ydhnMrCfsiQZ4ejyFqtXvNVJUJ/gdUrR8nuazPsrWC/S71Wkr4wpmhCdJgXTGHEQwGdGpyvA",
	"0mWkYrB5tYTLlKihv4R5yPtlQU6f3m0gSC+lobdh9QK0F6DbEKBNAU1HnGVWbuo9F1aQKqnK7S9TSIqX",
	"eic2nV+0V8y2l6l3GP7Ui9RepPYitRepm4vUXEz3XOWwPZ13csOK0gt2iLIsmRqcp6ZMSRuJmoupcz86",
	"Nvkw+8eFh8ahPdetxXWdEvivYdC/61QSvTrSqyO9OtKrI5sLxrzhveM09750IInFZSupmPcvE10YXEeT",
	"8bRLD96pklAvOG9LcLavgEpnopezT07OtqvGoyvZrKmCrl3M5ilL3F4g9ppkL+G2I+HapNZbV7b1l+v+",
	"ct2LxF4kfoEiUfWIR/M1JCMi2p1Q9UYpi9tLyjM7ZS8we4HZC8xeYH5JAlPmYvWDqE9Ymr4tZaSapX/e",
	"7OMcniSPtSpuu9YtrXfIeljWp1/ZDDpZp3tVoxeDT0QMzmm0R+gERIPR6lh/Lz2qZpjr9I0CcYiAzMoc",
	"VGrUWdWhdU4jlGcxluZbOxesszmNzJy9dnKrEmgtgdLLiCcmI3K6Kgz8o22xrsrk+vdqUx8K3vP9w+H7",
	"FsHgH8tGDyQcvAJRL0/6sO5bidLur269eL438RwlgHlYIr9WnxGmCDhnHH11vmN8+seYJBCf7+i0wHCN",
	"0yyBrxFZCEF0iSG15F0Vg6ineiK5Ons6v5V8meFsVneQSdNkQ90bkwSCWY1PQea8ptt461iwFLn5h+h4",
	"XPyhlBdqU3EmLMKJ/jJAMVOKzvU8UNWm4DA91xsF4JNOicsiCXJXSA44rZ9bJrhv59XOiFCToFzOM9h5",
	"tSMkJzRUNWewM9Xqi576/a+7b7GQu7+ymIwJxLVhYyxhV5LUbIBUSurOq53/PT+P/3x5s6v+ee7++WD+",
	"eVX756vz86H6v4PBdzdf//3ff/8vP4S9KPkSUu9GjAqWwCovFozEFJLEHa6KpjGhwEsTqkm+nzEBiCjh",
	"wFk+mSKMcp4gOcUSRZiiESCWATXmVYxGnF0J4Mhk9ZdyviummMNnFCUkUB+reli7oNbXdg1P1rTa6Xrw",
	"EweQH0gKLO+iv58Blt4AhwOPwsYBK3W6JpPeVsr3PVBx8SDLGiyLli2xfsLCte/OdMYkClcoYRPRfKK/",
	"ZZMn6HTxliklpuX1XzVmScKuWjZ+Syi0iiaScC33YAbUr0qsKHfal4L48g/wIuVEo84fLrhjbgOiONaB",
	"SsTG+k9bZA9icyXAwv5q8I5GLJ4P0BWRxm9Ltfn//9//T6AUJI6xxOgrdeUmdMzUpTxK8hhip0AUg9gD",
	"Yog+TIlAhYxRlwxjXAWuFFfV0wAlMoi0TmuAUthRjWfAza9YWDXE6Bh0OX/GiguK0yoe4xWlg6GyRMIG",
	"XU+7P7Pc9r3oJ87yzKODDO790qQhOAGehqD7KIA/YO3pIdonu1aE6ix1XaKfVZaWWvIeJPEoASdmFx+Y",
	"2omnx5jJ5zYt/lW89XrP/dn61X7EeTvzpGu7Cb+cufl6XmnNKw5nD59PvpAb+23zlMSyvAA4O15d7+GQ",
	"YElmsKvG8mkRTZY2/aT8aG32bUqJb1stvXlCFUBf7n/Xpu13XyaTbmpGU7xxRya0u7BZrW6roH4Axq1H",
	"Xrs0U7InRJdYXJqczZIh1RDhJEFRkuuc+eqDGIaJ9USNvP06t1+W/Hsw+7y5Pq3GatjurSnQvcb6sAhH",
	"TPemTMhLmItWxCOmKMtHCYmQ6oZUPyRM4uIMgOsHXslzoV1DUkQoIlKgS8qu6IXqIbTFtonSzn7+2QF0",
	"+8SmT5cswWSBzFpqbz0tLdDSJcw7ktElzFEMY2L9AbQcEmKqfvbTFZGOqnAup4yTPyC+0HS4mrJ+gXlP",
	"VF8cUel915fa3ENWH5y0WaAqoY42TTtBXeYkd4ShB7lnfeax7+RcSEj3YiIugyLinwSu9FbqViE+1gMd",
	"mRYPVxtRAPaaSFfymLiXuWb6MM0aCeQn2+ThUoiGsCeRriQyxTy+whxWU4lrKZop5Wc34EMmFgdkTy9d",
	"6YVkOI45CLEVsXJ8cmhHe8jUUkDZk0tXcslwdIknLaSLa9hILidFo4dLLBbGnlS6k4qMpm0IRTVbQSam",
	"yUMmEhlNexLpTCJc7bqct6AS17KZUMpWD5hWLJA9uXQlF4HpHqFEEiwZX00zZdNGojk7fHdcafmALfiH",
	"79RkBbA9Aa1DQM65o5l2JOYTkGIl5agN+RKIpqeVrrSSW1fiZjpRrVZQifZJfsgkogDs6cNHH8aPMkgF",
	"CmnaL8C0E0Xsp3ETCLy2vDeNO5OEIoj3emqc3C5BGAh7ktAkYWlgkSiaz5HKa16iiISNnU+u6iZQqu4L",
	"hE7MywzYkrZwnXEQOq3ShMyAugyLOoKnoIRGsjKeQ+uQ1l2QlPVrepQeR010UnNMFbPIeaXGJvN+Q5V5",
	"00BTwdWUJYDELEKMI8FS7Z1CpCgCJwIZwM9mkR1m3VOou6PprYZnbyuFZe9OFSDipSDqFqQMtJmSf6Tb",
	"IGQzSk/HPR1vlY5rsQKVQz1wyN4d/T20sBez/mMJ6aM+xQt39+JPE9Ze/Gmi2cvGUGtcj11vRXQu/yYe",
	"sXopuWUxaPbApuXTzZ8uOfJoCkIaBP0jh/yhJyjsFhPybZu23z7I+JH1+MglhrsFxoohAQntOevItO9Z",
	"q2etnrWaWWs5U3wza73ZKO97z1o9a90Ha63JHBMyA11VsTV7/OR69AzSM8hDZpA1OcJbYKCZJU42Te7f",
	"80TPE1/QoZHlfALt6m8UNlOdXtbccio5YIbn9IiIS/1xXLGwoilLYhRjiYfoB7jCHAaoUvsD5SLHSTK3",
	"A5q0drr1OT3J+UQHRGsTbszAJLvWMOt2M1a+iOaiLBQmZlEoX22N2fXie0bvGf3xMzoHXaeh/Ul4ajs8",
	"fPZokzKmo+NkABeaO9SEhENsU9j1DNprp2txZEd+PPtCuLHnhZ4X1uCFer3sVaywfg3snhN6TnjQnHBF",
	"bDBTS14w7XstrUBFr6T17Lg1dlxdnfgwSdgVwrlkKZYk0oXw2Aw4YmNtttA5+T+zgkrg+yn+PDynpp+c",
	"Avo9ZzxP0YxJ0NXz5FRX9dKJwMpWrnSeAQxdTYGiz/bH7xWRf65aaDigGCYcxxBriwxlusK60iHxKIE2",
	"1pFNyyb3J23P2l+QgaRzPeK6PfQSIAuW8bsF22gFEo+JNF+om7yhoXQLRY97adBLgy9BGhi+Xe2Za0pn",
	"PmxuaO3u/eMMJzmWXbocpxlwwWi3Xr/A/IrxWNwup9pZ+rCyW/fi0vV3zHV1IZzIPA8K0OeHUMeaAKkP",
	"QPXvpaUDF8cYrH3ric9QEz5CHjQY61L2/aNCaac68SBvmfNeszQlUj6mk/GJeVput2g1piaVrLkFYxRD",
	"lrC5Lj1nC8agt4xd2msv+MaxGmxZ3RqNCRdSl8Fe+DDFSvstSwbUatSsLIpdlSmblNfoC1z3Ba6/2NN8",
	"hc35i+KOvpTMEyslc8u8kftYI+85o+eMJ80Za+mX7gLYJa+JyLOMcQlx7fpopl2t0hWmh0dyXeRk1q52",
	"VHH501fxDj1MCqA7MdUcwVjn0GP0fow2T4wJYyzxKs7DSEieRzLnEBcseAlzbcOZ4SQH4Z4UGi9UR2qu",
	"x8Fzv8Bcg3TLBQuwxL/AXGcvepI3m40Mj4dIEDpJYFdyTIV9LI9YqnQV/f9sjHAcD1A0xXQCiHEXylDQ",
	"r3A2h0uY72pKR0Iyrv/21y8pTZIPn9pvyxlH4aBKuqt9cL40/e92XsheHrSB4eCB8mH3c8fVpirTJHhf",
	"DrA+a7QR0cOKPi40HUs23KDI1MM8d/qMTLdxjqzQgfRhomnRkB82XhgOXDRi8Xyl/vMkSPHW7M9flgHg",
	"4SpMXo+m1xywFrcUrjSZE9pW4JZm4cdM43dgK3tkitIXrdAM/NUNX5vbgval01yhrhEUwTURktBJV87J",
	"e8bpGedxMc56NwHRnPLc8pPowFuLipd4uh6rFgPOpNo739w5mTtP7z1Cx6zNW4frgFSHsjR8mfq/8G5p",
	"trqe2nGO1bxPlgGqWHj43qBflFdaV05QWxLn7ZzKXNs6/VfczdrxwJmb8snSv8NAT/u3RfsZUJyRpnCB",
	"sys8mei6PBtts9V+be2Hh50S2+HQFIGvoCtjLGnC1QljyTr6mr59qM4dLyy6dJKtiXLLpfgYS1Zx4Rds",
	"c9UbW9/nvRlL8hRWbfc/dastbPpt754B9OnsIYcEz/dSEKJehXdpF09Vw19tu67bqDu/sxXR2nCu7vDa",
	"lL06Pmrd46MATu9A36yg4nFSiSaLFb7CCxRxW7kfVmFbAYiwCQ2IscQCpI1KQHoVaAqYyxFgudMyYcQq",
	"U9L+k3poc6RQlxhCYpmHzTo/gURWqAin2euO9cBkA2VM6MRlQvigYz0mhO5lWIgrxmPTQTI0BhlN9Y2Z",
	"p8bJA3NjqxU4Nf9TbLWeJnBt0AR1ZuBfS5CJ1vLoFFIm70IameU84mNrmQrNnb/5yLIB+BuWRly92epo",
	"69L+lMR3U3nRoSBEGROQpTHKOO0OyhwkNEaWz5+WwLOk9enm5ubm/wQAAP//ggE+f9qHAgA=",
}

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