github.com/pingcap/tiflow@v0.0.0-20240520035814-5bf52d54e205/dm/openapi/gen.server.go

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

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

	"github.com/deepmap/oapi-codegen/pkg/runtime"
	"github.com/getkin/kin-openapi/openapi3"
	"github.com/gin-gonic/gin"
)

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// get cluster info such as cluster id
	// (GET /api/v1/cluster/info)
	DMAPIGetClusterInfo(c *gin.Context)
	// update cluster info.
	// (PUT /api/v1/cluster/info)
	DMAPIUpdateClusterInfo(c *gin.Context)
	// get cluster master node list
	// (GET /api/v1/cluster/masters)
	DMAPIGetClusterMasterList(c *gin.Context)
	// offline master node
	// (DELETE /api/v1/cluster/masters/{master-name})
	DMAPIOfflineMasterNode(c *gin.Context, masterName string)
	// get cluster worker node list
	// (GET /api/v1/cluster/workers)
	DMAPIGetClusterWorkerList(c *gin.Context)
	// offline worker node
	// (DELETE /api/v1/cluster/workers/{worker-name})
	DMAPIOfflineWorkerNode(c *gin.Context, workerName string)
	// get doc json
	// (GET /api/v1/dm.json)
	GetDocJSON(c *gin.Context)
	// get doc html
	// (GET /api/v1/docs)
	GetDocHTML(c *gin.Context)
	// get data source list
	// (GET /api/v1/sources)
	DMAPIGetSourceList(c *gin.Context, params DMAPIGetSourceListParams)
	// create and enable a new data source
	// (POST /api/v1/sources)
	DMAPICreateSource(c *gin.Context)
	// delete a data source
	// (DELETE /api/v1/sources/{source-name})
	DMAPIDeleteSource(c *gin.Context, sourceName string, params DMAPIDeleteSourceParams)
	// get source
	// (GET /api/v1/sources/{source-name})
	DMAPIGetSource(c *gin.Context, sourceName string, params DMAPIGetSourceParams)
	// update a data source
	// (PUT /api/v1/sources/{source-name})
	DMAPIUpdateSource(c *gin.Context, sourceName string)
	// disable a data source
	// (POST /api/v1/sources/{source-name}/disable)
	DMAPIDisableSource(c *gin.Context, sourceName string)
	// enable a data source
	// (POST /api/v1/sources/{source-name}/enable)
	DMAPIEnableSource(c *gin.Context, sourceName string)
	// disable relay log function for the data source
	// (POST /api/v1/sources/{source-name}/relay/disable)
	DMAPIDisableRelay(c *gin.Context, sourceName string)
	// enable relay log function for the data source
	// (POST /api/v1/sources/{source-name}/relay/enable)
	DMAPIEnableRelay(c *gin.Context, sourceName string)
	// purge relay log
	// (POST /api/v1/sources/{source-name}/relay/purge)
	DMAPIPurgeRelay(c *gin.Context, sourceName string)
	// get source schema list
	// (GET /api/v1/sources/{source-name}/schemas)
	DMAPIGetSourceSchemaList(c *gin.Context, sourceName string)
	// get source table list
	// (GET /api/v1/sources/{source-name}/schemas/{schema-name})
	DMAPIGetSourceTableList(c *gin.Context, sourceName string, schemaName string)
	// get the current status of the data source
	// (GET /api/v1/sources/{source-name}/status)
	DMAPIGetSourceStatus(c *gin.Context, sourceName string)
	// transfer source to a free worker
	// (POST /api/v1/sources/{source-name}/transfer)
	DMAPITransferSource(c *gin.Context, sourceName string)
	// get task list
	// (GET /api/v1/tasks)
	DMAPIGetTaskList(c *gin.Context, params DMAPIGetTaskListParams)
	// create a task
	// (POST /api/v1/tasks)
	DMAPICreateTask(c *gin.Context)
	// Turn task into the format of a configuration file or vice versa.
	// (POST /api/v1/tasks/converters)
	DMAPIConvertTask(c *gin.Context)
	// get task template list
	// (GET /api/v1/tasks/templates)
	DMAPIGetTaskTemplateList(c *gin.Context)
	// create task template
	// (POST /api/v1/tasks/templates)
	DMAPICreateTaskTemplate(c *gin.Context)
	// import task template
	// (POST /api/v1/tasks/templates/import)
	DMAPIImportTaskTemplate(c *gin.Context)
	// delete task template template
	// (DELETE /api/v1/tasks/templates/{task-name})
	DMAPIDeleteTaskTemplate(c *gin.Context, taskName string)
	// get task template template
	// (GET /api/v1/tasks/templates/{task-name})
	DMAPIGetTaskTemplate(c *gin.Context, taskName string)
	// update task template template
	// (PUT /api/v1/tasks/templates/{task-name})
	DMAPUpdateTaskTemplate(c *gin.Context, taskName string)
	// delete a task
	// (DELETE /api/v1/tasks/{task-name})
	DMAPIDeleteTask(c *gin.Context, taskName string, params DMAPIDeleteTaskParams)
	// get a task
	// (GET /api/v1/tasks/{task-name})
	DMAPIGetTask(c *gin.Context, taskName string, params DMAPIGetTaskParams)
	// update a task
	// (PUT /api/v1/tasks/{task-name})
	DMAPIUpdateTask(c *gin.Context, taskName string)
	// get task source table and target table route relation
	// (GET /api/v1/tasks/{task-name}/sources/{source-name}/migrate_targets)
	DMAPIGetTaskMigrateTargets(c *gin.Context, taskName string, sourceName string, params DMAPIGetTaskMigrateTargetsParams)
	// get task source schema list
	// (GET /api/v1/tasks/{task-name}/sources/{source-name}/schemas)
	DMAPIGetSchemaListByTaskAndSource(c *gin.Context, taskName string, sourceName string)
	// get task source table list
	// (GET /api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name})
	DMAPIGetTableListByTaskAndSource(c *gin.Context, taskName string, sourceName string, schemaName string)
	// delete task source table structure
	// (DELETE /api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name})
	DMAPIDeleteTableStructure(c *gin.Context, taskName string, sourceName string, schemaName string, tableName string)
	// get task source table structure
	// (GET /api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name})
	DMAPIGetTableStructure(c *gin.Context, taskName string, sourceName string, schemaName string, tableName string)
	// operate task source table structure
	// (PUT /api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name})
	DMAPIOperateTableStructure(c *gin.Context, taskName string, sourceName string, schemaName string, tableName string)
	// start a task
	// (POST /api/v1/tasks/{task-name}/start)
	DMAPIStartTask(c *gin.Context, taskName string)
	// get task status
	// (GET /api/v1/tasks/{task-name}/status)
	DMAPIGetTaskStatus(c *gin.Context, taskName string, params DMAPIGetTaskStatusParams)
	// stop a task
	// (POST /api/v1/tasks/{task-name}/stop)
	DMAPIStopTask(c *gin.Context, taskName string)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
}

type MiddlewareFunc func(c *gin.Context)

// DMAPIGetClusterInfo operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetClusterInfo(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetClusterInfo(c)
}

// DMAPIUpdateClusterInfo operation middleware
func (siw *ServerInterfaceWrapper) DMAPIUpdateClusterInfo(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIUpdateClusterInfo(c)
}

// DMAPIGetClusterMasterList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetClusterMasterList(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetClusterMasterList(c)
}

// DMAPIOfflineMasterNode operation middleware
func (siw *ServerInterfaceWrapper) DMAPIOfflineMasterNode(c *gin.Context) {
	var err error

	// ------------- Path parameter "master-name" -------------
	var masterName string

	err = runtime.BindStyledParameter("simple", false, "master-name", c.Param("master-name"), &masterName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter master-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIOfflineMasterNode(c, masterName)
}

// DMAPIGetClusterWorkerList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetClusterWorkerList(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetClusterWorkerList(c)
}

// DMAPIOfflineWorkerNode operation middleware
func (siw *ServerInterfaceWrapper) DMAPIOfflineWorkerNode(c *gin.Context) {
	var err error

	// ------------- Path parameter "worker-name" -------------
	var workerName string

	err = runtime.BindStyledParameter("simple", false, "worker-name", c.Param("worker-name"), &workerName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter worker-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIOfflineWorkerNode(c, workerName)
}

// GetDocJSON operation middleware
func (siw *ServerInterfaceWrapper) GetDocJSON(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.GetDocJSON(c)
}

// GetDocHTML operation middleware
func (siw *ServerInterfaceWrapper) GetDocHTML(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.GetDocHTML(c)
}

// DMAPIGetSourceList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSourceList(c *gin.Context) {
	var err error

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

	// ------------- Optional query parameter "with_status" -------------
	if paramValue := c.Query("with_status"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "with_status", c.Request.URL.Query(), &params.WithStatus)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter with_status: %s", err)})
		return
	}

	// ------------- Optional query parameter "enable_relay" -------------
	if paramValue := c.Query("enable_relay"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "enable_relay", c.Request.URL.Query(), &params.EnableRelay)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter enable_relay: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSourceList(c, params)
}

// DMAPICreateSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPICreateSource(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPICreateSource(c)
}

// DMAPIDeleteSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDeleteSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "force" -------------
	if paramValue := c.Query("force"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "force", c.Request.URL.Query(), &params.Force)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter force: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDeleteSource(c, sourceName, params)
}

// DMAPIGetSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "with_status" -------------
	if paramValue := c.Query("with_status"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "with_status", c.Request.URL.Query(), &params.WithStatus)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter with_status: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSource(c, sourceName, params)
}

// DMAPIUpdateSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIUpdateSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIUpdateSource(c, sourceName)
}

// DMAPIDisableSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDisableSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDisableSource(c, sourceName)
}

// DMAPIEnableSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIEnableSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIEnableSource(c, sourceName)
}

// DMAPIDisableRelay operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDisableRelay(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDisableRelay(c, sourceName)
}

// DMAPIEnableRelay operation middleware
func (siw *ServerInterfaceWrapper) DMAPIEnableRelay(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIEnableRelay(c, sourceName)
}

// DMAPIPurgeRelay operation middleware
func (siw *ServerInterfaceWrapper) DMAPIPurgeRelay(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIPurgeRelay(c, sourceName)
}

// DMAPIGetSourceSchemaList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSourceSchemaList(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSourceSchemaList(c, sourceName)
}

// DMAPIGetSourceTableList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSourceTableList(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	// ------------- Path parameter "schema-name" -------------
	var schemaName string

	err = runtime.BindStyledParameter("simple", false, "schema-name", c.Param("schema-name"), &schemaName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSourceTableList(c, sourceName, schemaName)
}

// DMAPIGetSourceStatus operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSourceStatus(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSourceStatus(c, sourceName)
}

// DMAPITransferSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPITransferSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPITransferSource(c, sourceName)
}

// DMAPIGetTaskList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTaskList(c *gin.Context) {
	var err error

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

	// ------------- Optional query parameter "with_status" -------------
	if paramValue := c.Query("with_status"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "with_status", c.Request.URL.Query(), &params.WithStatus)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter with_status: %s", err)})
		return
	}

	// ------------- Optional query parameter "stage" -------------
	if paramValue := c.Query("stage"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "stage", c.Request.URL.Query(), &params.Stage)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter stage: %s", err)})
		return
	}

	// ------------- Optional query parameter "source_name_list" -------------
	if paramValue := c.Query("source_name_list"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "source_name_list", c.Request.URL.Query(), &params.SourceNameList)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source_name_list: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTaskList(c, params)
}

// DMAPICreateTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPICreateTask(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPICreateTask(c)
}

// DMAPIConvertTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIConvertTask(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIConvertTask(c)
}

// DMAPIGetTaskTemplateList operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTaskTemplateList(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTaskTemplateList(c)
}

// DMAPICreateTaskTemplate operation middleware
func (siw *ServerInterfaceWrapper) DMAPICreateTaskTemplate(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPICreateTaskTemplate(c)
}

// DMAPIImportTaskTemplate operation middleware
func (siw *ServerInterfaceWrapper) DMAPIImportTaskTemplate(c *gin.Context) {
	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIImportTaskTemplate(c)
}

// DMAPIDeleteTaskTemplate operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDeleteTaskTemplate(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDeleteTaskTemplate(c, taskName)
}

// DMAPIGetTaskTemplate operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTaskTemplate(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTaskTemplate(c, taskName)
}

// DMAPUpdateTaskTemplate operation middleware
func (siw *ServerInterfaceWrapper) DMAPUpdateTaskTemplate(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPUpdateTaskTemplate(c, taskName)
}

// DMAPIDeleteTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDeleteTask(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "force" -------------
	if paramValue := c.Query("force"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "force", c.Request.URL.Query(), &params.Force)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter force: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDeleteTask(c, taskName, params)
}

// DMAPIGetTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTask(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "with_status" -------------
	if paramValue := c.Query("with_status"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "with_status", c.Request.URL.Query(), &params.WithStatus)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter with_status: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTask(c, taskName, params)
}

// DMAPIUpdateTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIUpdateTask(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIUpdateTask(c, taskName)
}

// DMAPIGetTaskMigrateTargets operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTaskMigrateTargets(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "schema_pattern" -------------
	if paramValue := c.Query("schema_pattern"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "schema_pattern", c.Request.URL.Query(), &params.SchemaPattern)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema_pattern: %s", err)})
		return
	}

	// ------------- Optional query parameter "table_pattern" -------------
	if paramValue := c.Query("table_pattern"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "table_pattern", c.Request.URL.Query(), &params.TablePattern)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter table_pattern: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTaskMigrateTargets(c, taskName, sourceName, params)
}

// DMAPIGetSchemaListByTaskAndSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetSchemaListByTaskAndSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetSchemaListByTaskAndSource(c, taskName, sourceName)
}

// DMAPIGetTableListByTaskAndSource operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTableListByTaskAndSource(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	// ------------- Path parameter "schema-name" -------------
	var schemaName string

	err = runtime.BindStyledParameter("simple", false, "schema-name", c.Param("schema-name"), &schemaName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTableListByTaskAndSource(c, taskName, sourceName, schemaName)
}

// DMAPIDeleteTableStructure operation middleware
func (siw *ServerInterfaceWrapper) DMAPIDeleteTableStructure(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	// ------------- Path parameter "schema-name" -------------
	var schemaName string

	err = runtime.BindStyledParameter("simple", false, "schema-name", c.Param("schema-name"), &schemaName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema-name: %s", err)})
		return
	}

	// ------------- Path parameter "table-name" -------------
	var tableName string

	err = runtime.BindStyledParameter("simple", false, "table-name", c.Param("table-name"), &tableName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter table-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIDeleteTableStructure(c, taskName, sourceName, schemaName, tableName)
}

// DMAPIGetTableStructure operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTableStructure(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	// ------------- Path parameter "schema-name" -------------
	var schemaName string

	err = runtime.BindStyledParameter("simple", false, "schema-name", c.Param("schema-name"), &schemaName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema-name: %s", err)})
		return
	}

	// ------------- Path parameter "table-name" -------------
	var tableName string

	err = runtime.BindStyledParameter("simple", false, "table-name", c.Param("table-name"), &tableName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter table-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTableStructure(c, taskName, sourceName, schemaName, tableName)
}

// DMAPIOperateTableStructure operation middleware
func (siw *ServerInterfaceWrapper) DMAPIOperateTableStructure(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	// ------------- Path parameter "source-name" -------------
	var sourceName string

	err = runtime.BindStyledParameter("simple", false, "source-name", c.Param("source-name"), &sourceName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source-name: %s", err)})
		return
	}

	// ------------- Path parameter "schema-name" -------------
	var schemaName string

	err = runtime.BindStyledParameter("simple", false, "schema-name", c.Param("schema-name"), &schemaName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter schema-name: %s", err)})
		return
	}

	// ------------- Path parameter "table-name" -------------
	var tableName string

	err = runtime.BindStyledParameter("simple", false, "table-name", c.Param("table-name"), &tableName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter table-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIOperateTableStructure(c, taskName, sourceName, schemaName, tableName)
}

// DMAPIStartTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIStartTask(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIStartTask(c, taskName)
}

// DMAPIGetTaskStatus operation middleware
func (siw *ServerInterfaceWrapper) DMAPIGetTaskStatus(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

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

	// ------------- Optional query parameter "source_name_list" -------------
	if paramValue := c.Query("source_name_list"); paramValue != "" {
	}

	err = runtime.BindQueryParameter("form", true, false, "source_name_list", c.Request.URL.Query(), &params.SourceNameList)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter source_name_list: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIGetTaskStatus(c, taskName, params)
}

// DMAPIStopTask operation middleware
func (siw *ServerInterfaceWrapper) DMAPIStopTask(c *gin.Context) {
	var err error

	// ------------- Path parameter "task-name" -------------
	var taskName string

	err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)})
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
	}

	siw.Handler.DMAPIStopTask(c, taskName)
}

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

// RegisterHandlers creates http.Handler with routing matching OpenAPI spec.
func RegisterHandlers(router *gin.Engine, si ServerInterface) *gin.Engine {
	return RegisterHandlersWithOptions(router, si, GinServerOptions{})
}

// RegisterHandlersWithOptions creates http.Handler with additional options
func RegisterHandlersWithOptions(router *gin.Engine, si ServerInterface, options GinServerOptions) *gin.Engine {
	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
	}

	router.GET(options.BaseURL+"/api/v1/cluster/info", wrapper.DMAPIGetClusterInfo)

	router.PUT(options.BaseURL+"/api/v1/cluster/info", wrapper.DMAPIUpdateClusterInfo)

	router.GET(options.BaseURL+"/api/v1/cluster/masters", wrapper.DMAPIGetClusterMasterList)

	router.DELETE(options.BaseURL+"/api/v1/cluster/masters/:master-name", wrapper.DMAPIOfflineMasterNode)

	router.GET(options.BaseURL+"/api/v1/cluster/workers", wrapper.DMAPIGetClusterWorkerList)

	router.DELETE(options.BaseURL+"/api/v1/cluster/workers/:worker-name", wrapper.DMAPIOfflineWorkerNode)

	router.GET(options.BaseURL+"/api/v1/dm.json", wrapper.GetDocJSON)

	router.GET(options.BaseURL+"/api/v1/docs", wrapper.GetDocHTML)

	router.GET(options.BaseURL+"/api/v1/sources", wrapper.DMAPIGetSourceList)

	router.POST(options.BaseURL+"/api/v1/sources", wrapper.DMAPICreateSource)

	router.DELETE(options.BaseURL+"/api/v1/sources/:source-name", wrapper.DMAPIDeleteSource)

	router.GET(options.BaseURL+"/api/v1/sources/:source-name", wrapper.DMAPIGetSource)

	router.PUT(options.BaseURL+"/api/v1/sources/:source-name", wrapper.DMAPIUpdateSource)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/disable", wrapper.DMAPIDisableSource)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/enable", wrapper.DMAPIEnableSource)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/relay/disable", wrapper.DMAPIDisableRelay)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/relay/enable", wrapper.DMAPIEnableRelay)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/relay/purge", wrapper.DMAPIPurgeRelay)

	router.GET(options.BaseURL+"/api/v1/sources/:source-name/schemas", wrapper.DMAPIGetSourceSchemaList)

	router.GET(options.BaseURL+"/api/v1/sources/:source-name/schemas/:schema-name", wrapper.DMAPIGetSourceTableList)

	router.GET(options.BaseURL+"/api/v1/sources/:source-name/status", wrapper.DMAPIGetSourceStatus)

	router.POST(options.BaseURL+"/api/v1/sources/:source-name/transfer", wrapper.DMAPITransferSource)

	router.GET(options.BaseURL+"/api/v1/tasks", wrapper.DMAPIGetTaskList)

	router.POST(options.BaseURL+"/api/v1/tasks", wrapper.DMAPICreateTask)

	router.POST(options.BaseURL+"/api/v1/tasks/converters", wrapper.DMAPIConvertTask)

	router.GET(options.BaseURL+"/api/v1/tasks/templates", wrapper.DMAPIGetTaskTemplateList)

	router.POST(options.BaseURL+"/api/v1/tasks/templates", wrapper.DMAPICreateTaskTemplate)

	router.POST(options.BaseURL+"/api/v1/tasks/templates/import", wrapper.DMAPIImportTaskTemplate)

	router.DELETE(options.BaseURL+"/api/v1/tasks/templates/:task-name", wrapper.DMAPIDeleteTaskTemplate)

	router.GET(options.BaseURL+"/api/v1/tasks/templates/:task-name", wrapper.DMAPIGetTaskTemplate)

	router.PUT(options.BaseURL+"/api/v1/tasks/templates/:task-name", wrapper.DMAPUpdateTaskTemplate)

	router.DELETE(options.BaseURL+"/api/v1/tasks/:task-name", wrapper.DMAPIDeleteTask)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name", wrapper.DMAPIGetTask)

	router.PUT(options.BaseURL+"/api/v1/tasks/:task-name", wrapper.DMAPIUpdateTask)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/migrate_targets", wrapper.DMAPIGetTaskMigrateTargets)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/schemas", wrapper.DMAPIGetSchemaListByTaskAndSource)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/schemas/:schema-name", wrapper.DMAPIGetTableListByTaskAndSource)

	router.DELETE(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/schemas/:schema-name/:table-name", wrapper.DMAPIDeleteTableStructure)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/schemas/:schema-name/:table-name", wrapper.DMAPIGetTableStructure)

	router.PUT(options.BaseURL+"/api/v1/tasks/:task-name/sources/:source-name/schemas/:schema-name/:table-name", wrapper.DMAPIOperateTableStructure)

	router.POST(options.BaseURL+"/api/v1/tasks/:task-name/start", wrapper.DMAPIStartTask)

	router.GET(options.BaseURL+"/api/v1/tasks/:task-name/status", wrapper.DMAPIGetTaskStatus)

	router.POST(options.BaseURL+"/api/v1/tasks/:task-name/stop", wrapper.DMAPIStopTask)

	return router
}

// Base64 encoded, gzipped, json marshaled Swagger object
var swaggerSpec = []string{
	"H4sIAAAAAAAC/+x9bXPbOJLwX8Gj5z7sTEmWZDtO4qv9kMSerO+cl4o9tbe1lWMgEpSwJgEGAO3Rpvzf",
	"r/BCEiQBkrItx5pkP+w4Igh0N/odjea3UUjTjBJEBB8dfxvxcIVSqP58lSAm3kECl4hd0owmdLmWv2eM",
	"ZogJjNSoFeVC/hf9AdMsQaPj0Xz/+d5sb7Y3H41HYp3Jn7hgmCxHt+NRRll9+MvZy4NyHCYCLREb3d6O",
	"Rwx9zTFD0ej4n3oR8/LncjRd/AuFQs76Jsm5QOwdlP/fhhFGkfo1QjxkOBOYktGx+hVxDmgMxAqBMGcM",
	"EQFSNQkgNEKjsQut4xf7R07cYIKvUXsdShJMEOACityshrlZxl5BsByVsy4oTRAkctoEwQg54Mfcnknh",
	"YIYOmJTAFNW3TU/jQKyxF+rNAtkSurEmcsfm+FkISkYLUs1pgbDG/QdD8eh49P+nFZNODYdOnex5Ox4t",
	"GYwhgYPneavH21NoUpQzBAnWPI4FSnnffJoJ7ekMRSBjUP07YzRFYoVyPhjIj+Ur9sQ3lF3dGc6/q5f9",
	"cN76t1K/+t3kbEFzEgWc5ixEQcHI9TX1QyAfAjUcCKqlRdOsvWy65l+TyaxrQQGXjqX09OphKdy+RdRY",
	"1wptcdRTDBdHSfo6pC5COeWTkmvEJM9CfvUJfc2R5qL63grIr/pYSk6gGAnyqyCkJMbLIMaJg2j6IZAP",
	"ASZgDdMExJSlUICVEBk/nk4jGvK9DJNlCLO9kKbTf6+mAkeLKRdwkaCpXGSi58kZlPNO5HSTOE+SPSfZ",
	"+jDnGSUc/SlRtzlGoeOA1MkbDEGBLhQHeVlDM1gfhfQkltry8fykn+nNin6IH4iVXZRzLXqCudyYTyiB",
	"a2vZhh4M5R9SEXFBMwABk8MBM+PHDSgtKpWKvV+fv4cpOpejnQx/kqfZhfJDHCqz9E+iPM1ATnAbJrls",
	"ggSKAsWI6jfNu6PjUUTzRYKqvSN5upC+3HiEuMApFCgQVMAkYPRm6JsxJpivUBQs1gJt/NIGC2nIHFhh",
	"Io4OR70eau39cZtQLVSaYLqp5GK2U7IZr0EmeplNPQ0WmCR0GSwFjpz8wQQmS/D28uykMOZ5xgVDMAX6",
	"1ZqxQy/hPA739yconL2YzOfo5WSxD8PJbP9wH4bz+Ww2OzieT56/OHw5Go9IniQSr4bLWpnIGogeq1+A",
	"KPWZsv0DwNSGf4HJ3kz+b384LBE23k4M80Tyyt5UP9BL1GGTYESYoVBQtgY3K8SQAk3vS0KXAHOpGCQ/",
	"DYBgG9rhlDHK/o7F6h3i3OnrSJZR9gYgObbFRurXIJRuT+td9QyE2iVqStPYvJrype/N1ADVZxuqicY2",
	"PC5JeouE8WjPSEz9DkCoBwUusTDPAJbbVmqN3Kc2pKYZ5vI3w6YmnhZQ3bjpgERuux/DCAo4OHKoR9uO",
	"AEcpMGVpByhNKSly9W4kNP8+PBImlNkyEtr3eUDoK2dq+2Brh+FBATc+yJbBlz7cA9K8dPG3DPI7vGTK",
	"hWVLJPgDAl+b+DEweVjOyRfVnI8B/aU0wBeC5aHIGfJjoQEMQhV4BPxrUg9q3nw6fXV5Ci5fvT4/BV/E",
	"/Av4yxccfQGYiL/M57+A9x8uwfvfz8/Bq98vPwRn7998On13+v5y/PHT2btXn/4B/vv0H/qNX8D018v/",
	"90+j91EUYBKhPz6DN+e/X1yefjo9Ab9OfwGn79+evT/96xkh9OQ1ODn97dXv55fgzd9efbo4vfxrLuIX",
	"6eIQvPlwfv7q8rT4t3SrXGkJg1o7UosWzkSJcnYdw9Xv8wGRafl6MZdFVedWNZJ3D56ePpjNZvdOT59T",
	"GPWHXQmFkTvs6oiC/H5GigQ07rIlFBWq1vPS42/Tg9ElQ5w7H+o4ZThMDaq1AiJ7PmvpOioOwF0kb2Rh",
	"78sXvnT5IB56sX8076WG4fo+VvqgPHDUnbAKVyi8ChjiKixpclzG0ESNAGaEHQ1VDzEHGeQcRXvALer3",
	"SaKM6zD2YNrUxL1Br45TEFA6xBv0xknOV7UITgdb9Vn/zrBAXMVqGi+dSkZAYZBRTATg8hcowMk7EEKi",
	"JRkLAGMZGTBUxqXytSL91jqS4V+TIKREIOLAjX9NwJrm4AYSYWFY2zuHpQFfwnllagprIM3NGHwJ9/2P",
	"DtyP7mFf/tNpYNYkbCP7exbBguY0EzjFXOAQ8BVkkSSj1ADSeoMbLFY64262hpJkDXKOIhlhEwBNoApo",
	"GOaMA0y8c56cnIO0FpyWW9NMPlr75GJcx1nNNk5N72+WPubMFeRXGYlQ4p9nIKMJDteglnFux/5/ZJgZ",
	"v66Qp1lTmNQgnUEQWOdnyuXs+LkwIZ48iGXm5J/sWjt+5boHR7PW0pcrBIrBUoIyxDCNcAiTZA2Myovb",
	"KRmNVjQGZnJwDZMcHQO1hGQojkJKIn436BlKISYBz2CIahjMnzXhf4cJTvMUxAwhEGF+BdRbCoa3r++y",
	"/K2PJx40j/2Iebu+PF1tzQyFOF4b4Hm+sLJzMWWgBfYeOIsBoQLoN7HkCXXmLlWVAJQgcIOTBCyQUkB7",
	"4EJBas52jsE+RM+PDg8OJ/Hzl/FkPkcvJosI7RfpUOlovtCozPsTgA1Jb9PYJe9qW98oIW7TQ1k0fTRV",
	"CGVbxFXmOdAPK4/QsmE/88g7lUe+9XFJf7Riq+06l5jqiSr0qE/RoGFxEKrFRBuWiqh/aVB1Pgbzl89f",
	"/uIS9tq6HuZz8dw9mK2budwgaMIVVRASoIcHIIQiXAV5FqRlRVQdiJuV9FCYVOJqLMgz7UyVu2OFXz4x",
	"d+rVzfizwntvyvOFmtLlJrpLLwoiaq6sTfcpJ0S+3Kc568zqZCIbXdcO+4hegO1SxRfKXS2PY9pypt1Z",
	"pXvU8c64SpL1Z2EaibELFOYMi3V7GeVEm1oZzpO6h6fNW4xREpWWbYWjCBHtXC+RKIMae6LaJCBmNFVD",
	"lO8VSz+nrZYa4StiIoBJQm9QFISkDfYbmqaUgPdGM19cnAP5Do5xCHXyoCRWL3E4T4IQ+gMva2KtqoqR",
	"Nrc5eVZOLDHxTv2bNZ3E4+PpO+MtTP/n2exlURXSQK1/1Su09i/6plpP7krG8LVE7Qqty5IUa/Ge9ZqR",
	"UZ2WDhq0AXRKhwnK3jKaZ460cZS0S916NzrGjIsgoaG2Mq5XZDSKos2mFTqb7hqak80nbCVL1OzjCucW",
	"IiXY1oJOopZVOq5SOY+vV/NLYpjwVnqktCQqCtcaQIZN6vWaijevt62JcSsrczloPSrdbO1EymgulwpK",
	"aWWudY7LvHtBiBN4TR3WTP9e1vWVtGq4fS5JLEJ8Z2GiqYl0Fz46MwCQ8xvKIu+M5YD6lAeHz46GeKJF",
	"hsE9t3xozXtwMDtyRbNZkVDoLGVVgypXpYxHul6yQxcpqJZF6zwzKsbJdwbWiw6uCtVex2ZFt73Hn5Bf",
	"DS/quIT8qirpGI9y7vL1DG7yYQs/RqkYWG0XODLUZsm6CBf/6tBCHY6PVbjrd3z0qMkw78cmuW+90oN0",
	"1bP0F6Voh4irvJ90iW4YdfmeBc/zEphenq9Y5R78y1CW4BB6+LhRjtnOmplqZuNtJ2u7ohq5dOKGdZwF",
	"Z9mAOHlHhuWdlZ0MpfQaBSnS58qDLYl+T+WVlSu7gFx5QhG9ISYeKn52p+5hjIKURigQOEVBVORI29ER",
	"ThEoHkuzIt8s8s6W3p5xp8apyDVIPzSETessJhSQDtggvzLlgmqADdD+bHY0mc0ns30wf3Y8OzyePRtW",
	"Yn0haNa5ZffHSQJLczGY6jcQ67hF40uzOumf8YGY1eoR2k5qnmYDBd2qyt2gEG6wzkkojAZCYh1UW4ee",
	"DjYpzug7OLRPSfmD/D6Td6EGGn99IGYXaxJWmKlTdjdm8hFQsNlcoc6pxi4XnyFOk2sUBcpDp+FV4DlK",
	"71SzxYURJ2ncJ8V+3VmQ0uDpVKUVOTpyfBJrd0WCyX/oeR3ILiQlMFlKqriWsE/dblY4XJUJMcxB8fJG",
	"cXwr6zgwP+gw0SEiIhDZ0EILcwAULNAKk8hKuQ15twwQHUZFPuvEqDbCj5Guq0DXxR3PAXCZcvbBNLDk",
	"YCmD9q491wMa2w4ZAjmZFLPYW98p1rVMQW80bRPCRrK26+NhScH69jg3oykHLjpZ4bstVD62cgmzKo+4",
	"by7RV6LVlrRLU/nRVp4+NRHjRNKP5TqhAKMIy7dg8rE2uk/vv8bknC5/U5N9knO5zDIiK0hCFOhbt0FR",
	"nLeCZIl6az0sl1DHMIDnmYx01JGgKh3Ql3mjKAFZki8xGXLZFi8JZShQh8ySGUryNy70qmEgY8gcR6th",
	"zt26Rozr5E+/YkQCGjLUT5midKIc5SYRHE6vQp8LyorqC++BTTWpt4bK707Y3Miv3OEdJUGUq3BGOGZb",
	"0Ru5eStIIp1bjRMcChQpTFRkmqf6wDRLdCq6uMigiW/Jl6VmpZJR7r37uOMGrtVBCqVSF0GBpFmzFssQ",
	"56beZDQeVcUn7sW0WR+WFlHekHrByo3cJS3RV1sr4QtFUMEeNIkyMNIqxErN1yrEaUVCPonSxaGpLmgu",
	"FUuTs+RKZgxQY8bDi6WVUjUV0w1l08j9brBXuvT6BAr4WoaSRcLHzVoF5AVNDDfFeZJIREjIUIqIrmWG",
	"iaqPrQQIJslQR7ICoUd7NoSvib9zV5oM7bZfDt3uOi0RSCkgOTEHUBQnyAm6RknL9hilq6y9I5SSPxd+",
	"vkcf18bUSAuiNBmiew0Mpia8XdGXQSEQU7U02kb6gfENr+D63xOmYtn+EwbnDvyWJ4nhd6lMfBeXrdyF",
	"5MRSviQXtRNokMBk/W+XcFJ18sVoomuveJ7KKbPVmuMQJgCnRdK51NiGcbUGld6D/DOO63xvPWvRoVjo",
	"iUBD04whzidX15MMYsa7wTKjwdU1UKPd8DlWIRxzgUi47py/sGOYGMdcnejq+jfKpAWN1e29cjYAOc+Z",
	"VBZ14cgFdcEhp/MUYgnK4FIVDbT9gL1psX5gLHh7Zsyvgq85LVJ+NVcG8yugninwHftZrvRi9tY1u14+",
	"ECuGYFQvbjxsmjklD/oFuTshJSa6cYZMGgafW1HtjB6nrEApdC1+TOhSIiblz+BYZ8TqeQtDA4cLw/mR",
	"E0UDUT+KtrkIChD6uLB4QyoZFSzlOmu3QgSkCIlyAAKM3nC1sWZul5z6/TzrFKQc1eluBiVtt4GDX9kQ",
	"SpCKQkne3FfzqH2cFwW9zVgyZycSJk19UG5soTZ8Bb0W4upNYL3ZqaLsJAhV1XYe9aAfluqhV5D3pvIV",
	"dyWRz/adkZBtZvss98tj+iRTBQsowvoVg3m7Mtmei69JuGKU4H+XS6k5APoDhZqLpCfwNYdEYLWUu6w4",
	"SwZKdBORXrH20bB+u9Ad51XOgrrb2KKZ8RWraLW31sm8IYpiBSuE9F1RUz7rBkuYN4Yu4T7iMus1AG6C",
	"01jM5yz7cz1lNN2Z6eFXgxM9VXTZPuJo5B2rFWYHcTjbPzqY7L8In0/mc/R8Ao+eHUyOwtnixWH07GV8",
	"MDueT57PDueH+wfj2bPD54fRQWgNf3HwbH+yPzuIFvuHR1F0EB3PJ/PnM2dzpnolr9VsST2oSqp9b2a0",
	"TqBDt47ayulrx3mob/Nr8b4HlAlDCZROW/eVDWnNy3AtNHvcF8M244RbHYtuPE9T59ZzH14iNzEaHNBb",
	"nNyXJ7bh8G5DcVpVWOkLQbNMRQRV7elv5oqjM9PjzDL4y6V1OkNQ+1DaTm7wgdnXhkOnHqoJCv51qAz5",
	"eFi1Be+sMhvIl3a20pPJHoMbnEQhZFGRoq2nIReTX+95PtmqNvGdW4qqUK6dfhoAq3DC2lkpYZkLn50Q",
	"Hjtccc9DbkZEEdeXY0y+vMCYN7ZlfkcKDlzAZ5Eb5BneTsyRtesgaZUw76bpk6oN3E4t4F1K9LZUv+as",
	"WCtp4t11lGZSPryVK/QasRuGxWYJ8PIt7W0Ls0r5R//902rdftB9N8RjiBPVnIxftU8KOmrgnNfAS3Xa",
	"33ewUGDVpE7d1TQqeRgizj3gblZR3Z5r3KaGCyh9KflBWyEOV0N68UfuatjoGdZVtNIRbviLAdsbXa3o",
	"vX1qrplyUFgvQU2BIu9qodhXcnOH4sW+csVGg92Hb0HhbRG71R4UtyorKqQyTk5o6Ehbn7wDHzJEXn08",
	"Aycf3kiVy5LR8aivu+lEGs+JdmkxJabZqY4vYqpYHAuFeGuB4jj8eHQkCagSdxkiMMOj49GB+klqfLFS",
	"0E5hhqfX86nppDMtpjf+Utnk7ixSa736eFZvFKfKRbRmVfPtz2a6OWZ55QZmZf5v+i+uSxIrP6qzG7W7",
	"JZ2iesMsakWmNpHnaQrZenQscQBlSzoSU8DzcAUgB7U+dQIuudVDbvRZFe/7sNfKp0kAJYavabR+MNzb",
	"He9aSJtlwUKue/uE9yFXNKttxZ6T8LfjFj/qUh8+lCWr/n6Pw5iOfoJdZBmPDh8QjFaPSsfS2px3CIbV",
	"erwwXJtszPSb/kNFhLda/yVI+4GOnfoQxwkmSJPtvT5nzyCDKdK7/M/Wwb8FXhGTq8Y9UKxGhSEYWTCM",
	"bDWuSyZc+U1/h//PLcY5dPjhT2xHqaZro5H8oI0sHIaBElY1n3wcCXM0u9wxCbMa4G8kYWZjpt+MF7aR",
	"hBnvcYCE2eD5JcyC4ceWsPrnDDo3Mkr3CuCckvUWiRMa/tfFh/ceUaqDJecqb1y32S2iIVDLVVBFNGxA",
	"ZHzUDnD+dvnufBA4cmAPOCuhS4N84Oggr1/1VC1j+5hZyldx81b1cCgvsyme/pojtraYGotVUI5wMLG7",
	"5O527PiszRowJHKmm2rpyr6J6adTXApzgVBrI7MJDJ+3q30dXXodkmK3OkiKXtoNPmgOqfihiPFVjMZ9",
	"+29/dmFbzrbjyw6bO9zzB4OnzIk8eTunW5ICSKKimhUCgm7sXXdteFsHTL9ZJwv9Vu5EPSyZolMnLBO6",
	"UI3NcoK/5vX+HH6DVz/oGGTwvPej2wojpvqmLc0KSGDCTROxokOMSuiYcgqX6lBz3FNn7IDh1XwAYB9P",
	"jYfYkF3klcexadu0Jx36rOzdfujkRUN5KkCsPhfVti9dDNGXxtkZnvi8HbvnSuPf1hOhEtzb78MaT0wP",
	"mSwWvK9tm0b6A0kqCe53e8xnlHaLRftihidnWzSRH2BTqxZBHXuqv1b0c0u3uaWlG3rfHVUh2WbC+qno",
	"FPpjmhPXl99ujT3ZVc1QtWqMc6Kb/RbXXx+GwTZQHD84ezm+9bar3GWU1NaZq2xC1sFbVZfrH5e12p2+",
	"h7vBT5vTFAfUGhRvzkvWd9AHhNi6neuQZO0WWMffDG27AW69he2OHFAV/d508aovOTuUPabf9B9VBm8A",
	"s6ia76fHK+OOAl/P8hXuA5d31v9ulUvrvVF2i0l1/fPdebTs7zREg5UNEJ+ONey8OPMoZ0GND9jtCPvY",
	"X9mvmnk9hIclGCQ8Np/+97tXl2bYj55rbJez/llcrIIRSlVFAdRfptG1Aj3cpY94+jRT8f3OXgaSPA/5",
	"1WOefpt7U4t10UZSN9xzrVk8G2qwygaHXas65KO5bLOx5nij9LRlM7esalufaXUwoSJyYhp+Ph1FW0JV",
	"sbuuph9yvH+pO6Zt73Dfvi7wPY/2Xd8s3KFz/vKLffUdbqqzaUjJNWJF5W7X9uuB29z/ApQeFsCx5mHM",
	"ASZZLnSXe6NL9Rc/Cqx0v2fIr0wnJ/21CMrANQ4RuEaMw60yUQOl3WGjS1UgpahMTMts82EPGgPY/FpK",
	"i6h7AzivuDs2zKQWt8MeoZ51x1V7eTnvXjr+srrZtw1ZN3e6vp969wHwRPV5bWc3Ea6paTbTrdzP1KBH",
	"2vfmHdXN2WB/S/Dsjn423azuzhbfVLPSTWr4GtyxUXRs90t1hMUlLAODYl+j1Z2um/PfrG4q8MHGcne2",
	"afbDKfa2ve7acm+BXHXH+uem70xp2tB9b+nvu2ntp8oRXcXWCgZ0jQjAsfpeCOD5ogj7WNmr6Ge5tS/S",
	"H2AmdoYvHiFX+j20UyOIPPR1xusoqvbvfl9J9VNmgK1WUd8vwTj70ROMZXX1wASjZbI853NFD76iv+aQ",
	"dFCtbyffGUX26MURzjMW3R/f9GUf+Yoefh0+o26h3z2hGvPr45+Jt7ll507G1VmdXV0BSWS60ZofGM2F",
	"uYuGaxeL7y6Vg2vJyiqy12tJ61ckutsJ+g8ilD+r27r4213idm8u3rDkrSx2+8nSP4vwdlaWnJV4DyxK",
	"8r1FgjZMSSwSdCFYHoqc/ZSppyZTY39HWx/JCw4YTHP3V/t2P31fkzxusfimyZmfEvJTQubfJ1iqM9/u",
	"B0udYujPkpXpmZ+iuPHiP4ogPnyK0koKNuXwz1WLrSVuQ7PZ7bUK2FvnciHH/ICZ7xLvXb+Pqzb5jsnn",
	"YTeLrE/K7qCyL1ua73pt/Y5eYjLXKjT3bMadNOtVXjT7IXWXRnv3VRfN/JpLfXyEXRc7Wm8+v6b5XkRT",
	"iIlqPT+SpDYTuHXBqK/bfUTDwS3uTU/76dcch1cTpYEnuix1UnUFq+mYkcszU2hvF6obLFaTKLXgUcu2",
	"oSm6wJbjih9uP9/+XwAAAP//rLmSJF28AAA=",
}

// 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: %s", err)
	}
	zr, err := gzip.NewReader(bytes.NewReader(zipped))
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %s", err)
	}
	var buf bytes.Buffer
	_, err = buf.ReadFrom(zr)
	if err != nil {
		return nil, fmt.Errorf("error decompressing spec: %s", 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
}