github.com/pingcap/tiflow@v0.0.0-20240520035814-5bf52d54e205/dm/openapi/gen.client.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"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"

	"github.com/deepmap/oapi-codegen/pkg/runtime"
)

// RequestEditorFn  is the function signature for the RequestEditor callback function
type RequestEditorFn func(ctx context.Context, req *http.Request) error

// Doer performs HTTP requests.
//
// The standard http.Client implements this interface.
type HttpRequestDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

// Client which conforms to the OpenAPI3 specification for this service.
type Client struct {
	// The endpoint of the server conforming to this interface, with scheme,
	// https://api.deepmap.com for example. This can contain a path relative
	// to the server, such as https://api.deepmap.com/dev-test, and all the
	// paths in the swagger spec will be appended to the server.
	Server string

	// Doer for performing requests, typically a *http.Client with any
	// customized settings, such as certificate chains.
	Client HttpRequestDoer

	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditorFn
}

// ClientOption allows setting custom parameters during construction
type ClientOption func(*Client) error

// Creates a new Client, with reasonable defaults
func NewClient(server string, opts ...ClientOption) (*Client, error) {
	// create a client with sane default values
	client := Client{
		Server: server,
	}
	// mutate client and add all optional params
	for _, o := range opts {
		if err := o(&client); err != nil {
			return nil, err
		}
	}
	// ensure the server URL always has a trailing slash
	if !strings.HasSuffix(client.Server, "/") {
		client.Server += "/"
	}
	// create httpClient, if not already present
	if client.Client == nil {
		client.Client = &http.Client{}
	}
	return &client, nil
}

// WithHTTPClient allows overriding the default Doer, which is
// automatically created using http.Client. This is useful for tests.
func WithHTTPClient(doer HttpRequestDoer) ClientOption {
	return func(c *Client) error {
		c.Client = doer
		return nil
	}
}

// WithRequestEditorFn allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
	return func(c *Client) error {
		c.RequestEditors = append(c.RequestEditors, fn)
		return nil
	}
}

// The interface specification for the client above.
type ClientInterface interface {
	// DMAPIGetClusterInfo request
	DMAPIGetClusterInfo(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIUpdateClusterInfo request with any body
	DMAPIUpdateClusterInfoWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIUpdateClusterInfo(ctx context.Context, body DMAPIUpdateClusterInfoJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetClusterMasterList request
	DMAPIGetClusterMasterList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIOfflineMasterNode request
	DMAPIOfflineMasterNode(ctx context.Context, masterName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetClusterWorkerList request
	DMAPIGetClusterWorkerList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIOfflineWorkerNode request
	DMAPIOfflineWorkerNode(ctx context.Context, workerName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDocJSON request
	GetDocJSON(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// GetDocHTML request
	GetDocHTML(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSourceList request
	DMAPIGetSourceList(ctx context.Context, params *DMAPIGetSourceListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPICreateSource request with any body
	DMAPICreateSourceWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPICreateSource(ctx context.Context, body DMAPICreateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDeleteSource request
	DMAPIDeleteSource(ctx context.Context, sourceName string, params *DMAPIDeleteSourceParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSource request
	DMAPIGetSource(ctx context.Context, sourceName string, params *DMAPIGetSourceParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIUpdateSource request with any body
	DMAPIUpdateSourceWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIUpdateSource(ctx context.Context, sourceName string, body DMAPIUpdateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDisableSource request
	DMAPIDisableSource(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIEnableSource request
	DMAPIEnableSource(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDisableRelay request with any body
	DMAPIDisableRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIDisableRelay(ctx context.Context, sourceName string, body DMAPIDisableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIEnableRelay request with any body
	DMAPIEnableRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIEnableRelay(ctx context.Context, sourceName string, body DMAPIEnableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIPurgeRelay request with any body
	DMAPIPurgeRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIPurgeRelay(ctx context.Context, sourceName string, body DMAPIPurgeRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSourceSchemaList request
	DMAPIGetSourceSchemaList(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSourceTableList request
	DMAPIGetSourceTableList(ctx context.Context, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSourceStatus request
	DMAPIGetSourceStatus(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPITransferSource request with any body
	DMAPITransferSourceWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPITransferSource(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTaskList request
	DMAPIGetTaskList(ctx context.Context, params *DMAPIGetTaskListParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPICreateTask request with any body
	DMAPICreateTaskWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPICreateTask(ctx context.Context, body DMAPICreateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIConvertTask request with any body
	DMAPIConvertTaskWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIConvertTask(ctx context.Context, body DMAPIConvertTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTaskTemplateList request
	DMAPIGetTaskTemplateList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPICreateTaskTemplate request with any body
	DMAPICreateTaskTemplateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPICreateTaskTemplate(ctx context.Context, body DMAPICreateTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIImportTaskTemplate request with any body
	DMAPIImportTaskTemplateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIImportTaskTemplate(ctx context.Context, body DMAPIImportTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDeleteTaskTemplate request
	DMAPIDeleteTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTaskTemplate request
	DMAPIGetTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPUpdateTaskTemplate request
	DMAPUpdateTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDeleteTask request
	DMAPIDeleteTask(ctx context.Context, taskName string, params *DMAPIDeleteTaskParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTask request
	DMAPIGetTask(ctx context.Context, taskName string, params *DMAPIGetTaskParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIUpdateTask request with any body
	DMAPIUpdateTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIUpdateTask(ctx context.Context, taskName string, body DMAPIUpdateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTaskMigrateTargets request
	DMAPIGetTaskMigrateTargets(ctx context.Context, taskName string, sourceName string, params *DMAPIGetTaskMigrateTargetsParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetSchemaListByTaskAndSource request
	DMAPIGetSchemaListByTaskAndSource(ctx context.Context, taskName string, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTableListByTaskAndSource request
	DMAPIGetTableListByTaskAndSource(ctx context.Context, taskName string, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIDeleteTableStructure request
	DMAPIDeleteTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTableStructure request
	DMAPIGetTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIOperateTableStructure request with any body
	DMAPIOperateTableStructureWithBody(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIOperateTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, body DMAPIOperateTableStructureJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIStartTask request with any body
	DMAPIStartTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIStartTask(ctx context.Context, taskName string, body DMAPIStartTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIGetTaskStatus request
	DMAPIGetTaskStatus(ctx context.Context, taskName string, params *DMAPIGetTaskStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error)

	// DMAPIStopTask request with any body
	DMAPIStopTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error)

	DMAPIStopTask(ctx context.Context, taskName string, body DMAPIStopTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error)
}

func (c *Client) DMAPIGetClusterInfo(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetClusterInfoRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateClusterInfoWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateClusterInfoRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateClusterInfo(ctx context.Context, body DMAPIUpdateClusterInfoJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateClusterInfoRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetClusterMasterList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetClusterMasterListRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIOfflineMasterNode(ctx context.Context, masterName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIOfflineMasterNodeRequest(c.Server, masterName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetClusterWorkerList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetClusterWorkerListRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIOfflineWorkerNode(ctx context.Context, workerName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIOfflineWorkerNodeRequest(c.Server, workerName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetDocJSON(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDocJSONRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) GetDocHTML(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewGetDocHTMLRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSourceList(ctx context.Context, params *DMAPIGetSourceListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSourceListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateSourceWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateSourceRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateSource(ctx context.Context, body DMAPICreateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateSourceRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDeleteSource(ctx context.Context, sourceName string, params *DMAPIDeleteSourceParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDeleteSourceRequest(c.Server, sourceName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSource(ctx context.Context, sourceName string, params *DMAPIGetSourceParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSourceRequest(c.Server, sourceName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateSourceWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateSourceRequestWithBody(c.Server, sourceName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateSource(ctx context.Context, sourceName string, body DMAPIUpdateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateSourceRequest(c.Server, sourceName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDisableSource(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDisableSourceRequest(c.Server, sourceName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIEnableSource(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIEnableSourceRequest(c.Server, sourceName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDisableRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDisableRelayRequestWithBody(c.Server, sourceName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDisableRelay(ctx context.Context, sourceName string, body DMAPIDisableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDisableRelayRequest(c.Server, sourceName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIEnableRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIEnableRelayRequestWithBody(c.Server, sourceName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIEnableRelay(ctx context.Context, sourceName string, body DMAPIEnableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIEnableRelayRequest(c.Server, sourceName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIPurgeRelayWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIPurgeRelayRequestWithBody(c.Server, sourceName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIPurgeRelay(ctx context.Context, sourceName string, body DMAPIPurgeRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIPurgeRelayRequest(c.Server, sourceName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSourceSchemaList(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSourceSchemaListRequest(c.Server, sourceName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSourceTableList(ctx context.Context, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSourceTableListRequest(c.Server, sourceName, schemaName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSourceStatus(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSourceStatusRequest(c.Server, sourceName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPITransferSourceWithBody(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPITransferSourceRequestWithBody(c.Server, sourceName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPITransferSource(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPITransferSourceRequest(c.Server, sourceName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTaskList(ctx context.Context, params *DMAPIGetTaskListParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskListRequest(c.Server, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateTaskWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateTaskRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateTask(ctx context.Context, body DMAPICreateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateTaskRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIConvertTaskWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIConvertTaskRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIConvertTask(ctx context.Context, body DMAPIConvertTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIConvertTaskRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTaskTemplateList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskTemplateListRequest(c.Server)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateTaskTemplateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateTaskTemplateRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPICreateTaskTemplate(ctx context.Context, body DMAPICreateTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPICreateTaskTemplateRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIImportTaskTemplateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIImportTaskTemplateRequestWithBody(c.Server, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIImportTaskTemplate(ctx context.Context, body DMAPIImportTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIImportTaskTemplateRequest(c.Server, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDeleteTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDeleteTaskTemplateRequest(c.Server, taskName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskTemplateRequest(c.Server, taskName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPUpdateTaskTemplate(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPUpdateTaskTemplateRequest(c.Server, taskName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDeleteTask(ctx context.Context, taskName string, params *DMAPIDeleteTaskParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDeleteTaskRequest(c.Server, taskName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTask(ctx context.Context, taskName string, params *DMAPIGetTaskParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskRequest(c.Server, taskName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateTaskRequestWithBody(c.Server, taskName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIUpdateTask(ctx context.Context, taskName string, body DMAPIUpdateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIUpdateTaskRequest(c.Server, taskName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTaskMigrateTargets(ctx context.Context, taskName string, sourceName string, params *DMAPIGetTaskMigrateTargetsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskMigrateTargetsRequest(c.Server, taskName, sourceName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetSchemaListByTaskAndSource(ctx context.Context, taskName string, sourceName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetSchemaListByTaskAndSourceRequest(c.Server, taskName, sourceName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTableListByTaskAndSource(ctx context.Context, taskName string, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTableListByTaskAndSourceRequest(c.Server, taskName, sourceName, schemaName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIDeleteTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIDeleteTableStructureRequest(c.Server, taskName, sourceName, schemaName, tableName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTableStructureRequest(c.Server, taskName, sourceName, schemaName, tableName)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIOperateTableStructureWithBody(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIOperateTableStructureRequestWithBody(c.Server, taskName, sourceName, schemaName, tableName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIOperateTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, body DMAPIOperateTableStructureJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIOperateTableStructureRequest(c.Server, taskName, sourceName, schemaName, tableName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIStartTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIStartTaskRequestWithBody(c.Server, taskName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIStartTask(ctx context.Context, taskName string, body DMAPIStartTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIStartTaskRequest(c.Server, taskName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIGetTaskStatus(ctx context.Context, taskName string, params *DMAPIGetTaskStatusParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIGetTaskStatusRequest(c.Server, taskName, params)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIStopTaskWithBody(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIStopTaskRequestWithBody(c.Server, taskName, contentType, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

func (c *Client) DMAPIStopTask(ctx context.Context, taskName string, body DMAPIStopTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) {
	req, err := NewDMAPIStopTaskRequest(c.Server, taskName, body)
	if err != nil {
		return nil, err
	}
	req = req.WithContext(ctx)
	if err := c.applyEditors(ctx, req, reqEditors); err != nil {
		return nil, err
	}
	return c.Client.Do(req)
}

// NewDMAPIGetClusterInfoRequest generates requests for DMAPIGetClusterInfo
func NewDMAPIGetClusterInfoRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/info")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIUpdateClusterInfoRequest calls the generic DMAPIUpdateClusterInfo builder with application/json body
func NewDMAPIUpdateClusterInfoRequest(server string, body DMAPIUpdateClusterInfoJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIUpdateClusterInfoRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPIUpdateClusterInfoRequestWithBody generates requests for DMAPIUpdateClusterInfo with any type of body
func NewDMAPIUpdateClusterInfoRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/info")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetClusterMasterListRequest generates requests for DMAPIGetClusterMasterList
func NewDMAPIGetClusterMasterListRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/masters")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIOfflineMasterNodeRequest generates requests for DMAPIOfflineMasterNode
func NewDMAPIOfflineMasterNodeRequest(server string, masterName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "master-name", runtime.ParamLocationPath, masterName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/masters/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetClusterWorkerListRequest generates requests for DMAPIGetClusterWorkerList
func NewDMAPIGetClusterWorkerListRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/workers")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIOfflineWorkerNodeRequest generates requests for DMAPIOfflineWorkerNode
func NewDMAPIOfflineWorkerNodeRequest(server string, workerName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "worker-name", runtime.ParamLocationPath, workerName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/cluster/workers/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetDocJSONRequest generates requests for GetDocJSON
func NewGetDocJSONRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/dm.json")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewGetDocHTMLRequest generates requests for GetDocHTML
func NewGetDocHTMLRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/docs")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetSourceListRequest generates requests for DMAPIGetSourceList
func NewDMAPIGetSourceListRequest(server string, params *DMAPIGetSourceListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.WithStatus != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "with_status", runtime.ParamLocationQuery, *params.WithStatus); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	if params.EnableRelay != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "enable_relay", runtime.ParamLocationQuery, *params.EnableRelay); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPICreateSourceRequest calls the generic DMAPICreateSource builder with application/json body
func NewDMAPICreateSourceRequest(server string, body DMAPICreateSourceJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPICreateSourceRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPICreateSourceRequestWithBody generates requests for DMAPICreateSource with any type of body
func NewDMAPICreateSourceRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIDeleteSourceRequest generates requests for DMAPIDeleteSource
func NewDMAPIDeleteSourceRequest(server string, sourceName string, params *DMAPIDeleteSourceParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.Force != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "force", runtime.ParamLocationQuery, *params.Force); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetSourceRequest generates requests for DMAPIGetSource
func NewDMAPIGetSourceRequest(server string, sourceName string, params *DMAPIGetSourceParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.WithStatus != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "with_status", runtime.ParamLocationQuery, *params.WithStatus); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIUpdateSourceRequest calls the generic DMAPIUpdateSource builder with application/json body
func NewDMAPIUpdateSourceRequest(server string, sourceName string, body DMAPIUpdateSourceJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIUpdateSourceRequestWithBody(server, sourceName, "application/json", bodyReader)
}

// NewDMAPIUpdateSourceRequestWithBody generates requests for DMAPIUpdateSource with any type of body
func NewDMAPIUpdateSourceRequestWithBody(server string, sourceName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIDisableSourceRequest generates requests for DMAPIDisableSource
func NewDMAPIDisableSourceRequest(server string, sourceName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/disable", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIEnableSourceRequest generates requests for DMAPIEnableSource
func NewDMAPIEnableSourceRequest(server string, sourceName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/enable", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIDisableRelayRequest calls the generic DMAPIDisableRelay builder with application/json body
func NewDMAPIDisableRelayRequest(server string, sourceName string, body DMAPIDisableRelayJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIDisableRelayRequestWithBody(server, sourceName, "application/json", bodyReader)
}

// NewDMAPIDisableRelayRequestWithBody generates requests for DMAPIDisableRelay with any type of body
func NewDMAPIDisableRelayRequestWithBody(server string, sourceName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/relay/disable", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIEnableRelayRequest calls the generic DMAPIEnableRelay builder with application/json body
func NewDMAPIEnableRelayRequest(server string, sourceName string, body DMAPIEnableRelayJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIEnableRelayRequestWithBody(server, sourceName, "application/json", bodyReader)
}

// NewDMAPIEnableRelayRequestWithBody generates requests for DMAPIEnableRelay with any type of body
func NewDMAPIEnableRelayRequestWithBody(server string, sourceName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/relay/enable", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIPurgeRelayRequest calls the generic DMAPIPurgeRelay builder with application/json body
func NewDMAPIPurgeRelayRequest(server string, sourceName string, body DMAPIPurgeRelayJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIPurgeRelayRequestWithBody(server, sourceName, "application/json", bodyReader)
}

// NewDMAPIPurgeRelayRequestWithBody generates requests for DMAPIPurgeRelay with any type of body
func NewDMAPIPurgeRelayRequestWithBody(server string, sourceName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/relay/purge", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetSourceSchemaListRequest generates requests for DMAPIGetSourceSchemaList
func NewDMAPIGetSourceSchemaListRequest(server string, sourceName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/schemas", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetSourceTableListRequest generates requests for DMAPIGetSourceTableList
func NewDMAPIGetSourceTableListRequest(server string, sourceName string, schemaName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/schemas/%s", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetSourceStatusRequest generates requests for DMAPIGetSourceStatus
func NewDMAPIGetSourceStatusRequest(server string, sourceName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/status", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPITransferSourceRequest calls the generic DMAPITransferSource builder with application/json body
func NewDMAPITransferSourceRequest(server string, sourceName string, body DMAPITransferSourceJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPITransferSourceRequestWithBody(server, sourceName, "application/json", bodyReader)
}

// NewDMAPITransferSourceRequestWithBody generates requests for DMAPITransferSource with any type of body
func NewDMAPITransferSourceRequestWithBody(server string, sourceName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/sources/%s/transfer", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetTaskListRequest generates requests for DMAPIGetTaskList
func NewDMAPIGetTaskListRequest(server string, params *DMAPIGetTaskListParams) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.WithStatus != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "with_status", runtime.ParamLocationQuery, *params.WithStatus); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	if params.Stage != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "stage", runtime.ParamLocationQuery, *params.Stage); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	if params.SourceNameList != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "source_name_list", runtime.ParamLocationQuery, *params.SourceNameList); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPICreateTaskRequest calls the generic DMAPICreateTask builder with application/json body
func NewDMAPICreateTaskRequest(server string, body DMAPICreateTaskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPICreateTaskRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPICreateTaskRequestWithBody generates requests for DMAPICreateTask with any type of body
func NewDMAPICreateTaskRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIConvertTaskRequest calls the generic DMAPIConvertTask builder with application/json body
func NewDMAPIConvertTaskRequest(server string, body DMAPIConvertTaskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIConvertTaskRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPIConvertTaskRequestWithBody generates requests for DMAPIConvertTask with any type of body
func NewDMAPIConvertTaskRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/converters")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetTaskTemplateListRequest generates requests for DMAPIGetTaskTemplateList
func NewDMAPIGetTaskTemplateListRequest(server string) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPICreateTaskTemplateRequest calls the generic DMAPICreateTaskTemplate builder with application/json body
func NewDMAPICreateTaskTemplateRequest(server string, body DMAPICreateTaskTemplateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPICreateTaskTemplateRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPICreateTaskTemplateRequestWithBody generates requests for DMAPICreateTaskTemplate with any type of body
func NewDMAPICreateTaskTemplateRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIImportTaskTemplateRequest calls the generic DMAPIImportTaskTemplate builder with application/json body
func NewDMAPIImportTaskTemplateRequest(server string, body DMAPIImportTaskTemplateJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIImportTaskTemplateRequestWithBody(server, "application/json", bodyReader)
}

// NewDMAPIImportTaskTemplateRequestWithBody generates requests for DMAPIImportTaskTemplate with any type of body
func NewDMAPIImportTaskTemplateRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates/import")
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIDeleteTaskTemplateRequest generates requests for DMAPIDeleteTaskTemplate
func NewDMAPIDeleteTaskTemplateRequest(server string, taskName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetTaskTemplateRequest generates requests for DMAPIGetTaskTemplate
func NewDMAPIGetTaskTemplateRequest(server string, taskName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPUpdateTaskTemplateRequest generates requests for DMAPUpdateTaskTemplate
func NewDMAPUpdateTaskTemplateRequest(server string, taskName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/templates/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIDeleteTaskRequest generates requests for DMAPIDeleteTask
func NewDMAPIDeleteTaskRequest(server string, taskName string, params *DMAPIDeleteTaskParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.Force != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "force", runtime.ParamLocationQuery, *params.Force); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetTaskRequest generates requests for DMAPIGetTask
func NewDMAPIGetTaskRequest(server string, taskName string, params *DMAPIGetTaskParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.WithStatus != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "with_status", runtime.ParamLocationQuery, *params.WithStatus); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIUpdateTaskRequest calls the generic DMAPIUpdateTask builder with application/json body
func NewDMAPIUpdateTaskRequest(server string, taskName string, body DMAPIUpdateTaskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIUpdateTaskRequestWithBody(server, taskName, "application/json", bodyReader)
}

// NewDMAPIUpdateTaskRequestWithBody generates requests for DMAPIUpdateTask with any type of body
func NewDMAPIUpdateTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetTaskMigrateTargetsRequest generates requests for DMAPIGetTaskMigrateTargets
func NewDMAPIGetTaskMigrateTargetsRequest(server string, taskName string, sourceName string, params *DMAPIGetTaskMigrateTargetsParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/migrate_targets", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.SchemaPattern != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "schema_pattern", runtime.ParamLocationQuery, *params.SchemaPattern); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	if params.TablePattern != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "table_pattern", runtime.ParamLocationQuery, *params.TablePattern); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetSchemaListByTaskAndSourceRequest generates requests for DMAPIGetSchemaListByTaskAndSource
func NewDMAPIGetSchemaListByTaskAndSourceRequest(server string, taskName string, sourceName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas", pathParam0, pathParam1)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetTableListByTaskAndSourceRequest generates requests for DMAPIGetTableListByTaskAndSource
func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, sourceName string, schemaName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s", pathParam0, pathParam1, pathParam2)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIDeleteTableStructureRequest generates requests for DMAPIDeleteTableStructure
func NewDMAPIDeleteTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName)
	if err != nil {
		return nil, err
	}

	var pathParam3 string

	pathParam3, err = runtime.StyleParamWithLocation("simple", false, "table-name", runtime.ParamLocationPath, tableName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s/%s", pathParam0, pathParam1, pathParam2, pathParam3)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("DELETE", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIGetTableStructureRequest generates requests for DMAPIGetTableStructure
func NewDMAPIGetTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName)
	if err != nil {
		return nil, err
	}

	var pathParam3 string

	pathParam3, err = runtime.StyleParamWithLocation("simple", false, "table-name", runtime.ParamLocationPath, tableName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s/%s", pathParam0, pathParam1, pathParam2, pathParam3)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIOperateTableStructureRequest calls the generic DMAPIOperateTableStructure builder with application/json body
func NewDMAPIOperateTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string, body DMAPIOperateTableStructureJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIOperateTableStructureRequestWithBody(server, taskName, sourceName, schemaName, tableName, "application/json", bodyReader)
}

// NewDMAPIOperateTableStructureRequestWithBody generates requests for DMAPIOperateTableStructure with any type of body
func NewDMAPIOperateTableStructureRequestWithBody(server string, taskName string, sourceName string, schemaName string, tableName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	var pathParam1 string

	pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName)
	if err != nil {
		return nil, err
	}

	var pathParam2 string

	pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName)
	if err != nil {
		return nil, err
	}

	var pathParam3 string

	pathParam3, err = runtime.StyleParamWithLocation("simple", false, "table-name", runtime.ParamLocationPath, tableName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s/%s", pathParam0, pathParam1, pathParam2, pathParam3)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("PUT", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIStartTaskRequest calls the generic DMAPIStartTask builder with application/json body
func NewDMAPIStartTaskRequest(server string, taskName string, body DMAPIStartTaskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIStartTaskRequestWithBody(server, taskName, "application/json", bodyReader)
}

// NewDMAPIStartTaskRequestWithBody generates requests for DMAPIStartTask with any type of body
func NewDMAPIStartTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/start", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

// NewDMAPIGetTaskStatusRequest generates requests for DMAPIGetTaskStatus
func NewDMAPIGetTaskStatusRequest(server string, taskName string, params *DMAPIGetTaskStatusParams) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/status", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	queryValues := queryURL.Query()

	if params.SourceNameList != nil {
		if queryFrag, err := runtime.StyleParamWithLocation("form", true, "source_name_list", runtime.ParamLocationQuery, *params.SourceNameList); err != nil {
			return nil, err
		} else if parsed, err := url.ParseQuery(queryFrag); err != nil {
			return nil, err
		} else {
			for k, v := range parsed {
				for _, v2 := range v {
					queryValues.Add(k, v2)
				}
			}
		}
	}

	queryURL.RawQuery = queryValues.Encode()

	req, err := http.NewRequest("GET", queryURL.String(), nil)
	if err != nil {
		return nil, err
	}

	return req, nil
}

// NewDMAPIStopTaskRequest calls the generic DMAPIStopTask builder with application/json body
func NewDMAPIStopTaskRequest(server string, taskName string, body DMAPIStopTaskJSONRequestBody) (*http.Request, error) {
	var bodyReader io.Reader
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	bodyReader = bytes.NewReader(buf)
	return NewDMAPIStopTaskRequestWithBody(server, taskName, "application/json", bodyReader)
}

// NewDMAPIStopTaskRequestWithBody generates requests for DMAPIStopTask with any type of body
func NewDMAPIStopTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) {
	var err error

	var pathParam0 string

	pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName)
	if err != nil {
		return nil, err
	}

	serverURL, err := url.Parse(server)
	if err != nil {
		return nil, err
	}

	operationPath := fmt.Sprintf("/api/v1/tasks/%s/stop", pathParam0)
	if operationPath[0] == '/' {
		operationPath = "." + operationPath
	}

	queryURL, err := serverURL.Parse(operationPath)
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("POST", queryURL.String(), body)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Content-Type", contentType)

	return req, nil
}

func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
	for _, r := range c.RequestEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	for _, r := range additionalEditors {
		if err := r(ctx, req); err != nil {
			return err
		}
	}
	return nil
}

// ClientWithResponses builds on ClientInterface to offer response payloads
type ClientWithResponses struct {
	ClientInterface
}

// NewClientWithResponses creates a new ClientWithResponses, which wraps
// Client with return type handling
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
	client, err := NewClient(server, opts...)
	if err != nil {
		return nil, err
	}
	return &ClientWithResponses{client}, nil
}

// WithBaseURL overrides the baseURL.
func WithBaseURL(baseURL string) ClientOption {
	return func(c *Client) error {
		newBaseURL, err := url.Parse(baseURL)
		if err != nil {
			return err
		}
		c.Server = newBaseURL.String()
		return nil
	}
}

// ClientWithResponsesInterface is the interface specification for the client with responses above.
type ClientWithResponsesInterface interface {
	// DMAPIGetClusterInfo request
	DMAPIGetClusterInfoWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterInfoResponse, error)

	// DMAPIUpdateClusterInfo request with any body
	DMAPIUpdateClusterInfoWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateClusterInfoResponse, error)

	DMAPIUpdateClusterInfoWithResponse(ctx context.Context, body DMAPIUpdateClusterInfoJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateClusterInfoResponse, error)

	// DMAPIGetClusterMasterList request
	DMAPIGetClusterMasterListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterMasterListResponse, error)

	// DMAPIOfflineMasterNode request
	DMAPIOfflineMasterNodeWithResponse(ctx context.Context, masterName string, reqEditors ...RequestEditorFn) (*DMAPIOfflineMasterNodeResponse, error)

	// DMAPIGetClusterWorkerList request
	DMAPIGetClusterWorkerListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterWorkerListResponse, error)

	// DMAPIOfflineWorkerNode request
	DMAPIOfflineWorkerNodeWithResponse(ctx context.Context, workerName string, reqEditors ...RequestEditorFn) (*DMAPIOfflineWorkerNodeResponse, error)

	// GetDocJSON request
	GetDocJSONWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDocJSONResponse, error)

	// GetDocHTML request
	GetDocHTMLWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDocHTMLResponse, error)

	// DMAPIGetSourceList request
	DMAPIGetSourceListWithResponse(ctx context.Context, params *DMAPIGetSourceListParams, reqEditors ...RequestEditorFn) (*DMAPIGetSourceListResponse, error)

	// DMAPICreateSource request with any body
	DMAPICreateSourceWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateSourceResponse, error)

	DMAPICreateSourceWithResponse(ctx context.Context, body DMAPICreateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateSourceResponse, error)

	// DMAPIDeleteSource request
	DMAPIDeleteSourceWithResponse(ctx context.Context, sourceName string, params *DMAPIDeleteSourceParams, reqEditors ...RequestEditorFn) (*DMAPIDeleteSourceResponse, error)

	// DMAPIGetSource request
	DMAPIGetSourceWithResponse(ctx context.Context, sourceName string, params *DMAPIGetSourceParams, reqEditors ...RequestEditorFn) (*DMAPIGetSourceResponse, error)

	// DMAPIUpdateSource request with any body
	DMAPIUpdateSourceWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateSourceResponse, error)

	DMAPIUpdateSourceWithResponse(ctx context.Context, sourceName string, body DMAPIUpdateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateSourceResponse, error)

	// DMAPIDisableSource request
	DMAPIDisableSourceWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIDisableSourceResponse, error)

	// DMAPIEnableSource request
	DMAPIEnableSourceWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIEnableSourceResponse, error)

	// DMAPIDisableRelay request with any body
	DMAPIDisableRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIDisableRelayResponse, error)

	DMAPIDisableRelayWithResponse(ctx context.Context, sourceName string, body DMAPIDisableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIDisableRelayResponse, error)

	// DMAPIEnableRelay request with any body
	DMAPIEnableRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIEnableRelayResponse, error)

	DMAPIEnableRelayWithResponse(ctx context.Context, sourceName string, body DMAPIEnableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIEnableRelayResponse, error)

	// DMAPIPurgeRelay request with any body
	DMAPIPurgeRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIPurgeRelayResponse, error)

	DMAPIPurgeRelayWithResponse(ctx context.Context, sourceName string, body DMAPIPurgeRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIPurgeRelayResponse, error)

	// DMAPIGetSourceSchemaList request
	DMAPIGetSourceSchemaListWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceSchemaListResponse, error)

	// DMAPIGetSourceTableList request
	DMAPIGetSourceTableListWithResponse(ctx context.Context, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceTableListResponse, error)

	// DMAPIGetSourceStatus request
	DMAPIGetSourceStatusWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceStatusResponse, error)

	// DMAPITransferSource request with any body
	DMAPITransferSourceWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPITransferSourceResponse, error)

	DMAPITransferSourceWithResponse(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPITransferSourceResponse, error)

	// DMAPIGetTaskList request
	DMAPIGetTaskListWithResponse(ctx context.Context, params *DMAPIGetTaskListParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskListResponse, error)

	// DMAPICreateTask request with any body
	DMAPICreateTaskWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskResponse, error)

	DMAPICreateTaskWithResponse(ctx context.Context, body DMAPICreateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskResponse, error)

	// DMAPIConvertTask request with any body
	DMAPIConvertTaskWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIConvertTaskResponse, error)

	DMAPIConvertTaskWithResponse(ctx context.Context, body DMAPIConvertTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIConvertTaskResponse, error)

	// DMAPIGetTaskTemplateList request
	DMAPIGetTaskTemplateListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskTemplateListResponse, error)

	// DMAPICreateTaskTemplate request with any body
	DMAPICreateTaskTemplateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskTemplateResponse, error)

	DMAPICreateTaskTemplateWithResponse(ctx context.Context, body DMAPICreateTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskTemplateResponse, error)

	// DMAPIImportTaskTemplate request with any body
	DMAPIImportTaskTemplateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIImportTaskTemplateResponse, error)

	DMAPIImportTaskTemplateWithResponse(ctx context.Context, body DMAPIImportTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIImportTaskTemplateResponse, error)

	// DMAPIDeleteTaskTemplate request
	DMAPIDeleteTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskTemplateResponse, error)

	// DMAPIGetTaskTemplate request
	DMAPIGetTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIGetTaskTemplateResponse, error)

	// DMAPUpdateTaskTemplate request
	DMAPUpdateTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPUpdateTaskTemplateResponse, error)

	// DMAPIDeleteTask request
	DMAPIDeleteTaskWithResponse(ctx context.Context, taskName string, params *DMAPIDeleteTaskParams, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskResponse, error)

	// DMAPIGetTask request
	DMAPIGetTaskWithResponse(ctx context.Context, taskName string, params *DMAPIGetTaskParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskResponse, error)

	// DMAPIUpdateTask request with any body
	DMAPIUpdateTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateTaskResponse, error)

	DMAPIUpdateTaskWithResponse(ctx context.Context, taskName string, body DMAPIUpdateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateTaskResponse, error)

	// DMAPIGetTaskMigrateTargets request
	DMAPIGetTaskMigrateTargetsWithResponse(ctx context.Context, taskName string, sourceName string, params *DMAPIGetTaskMigrateTargetsParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskMigrateTargetsResponse, error)

	// DMAPIGetSchemaListByTaskAndSource request
	DMAPIGetSchemaListByTaskAndSourceWithResponse(ctx context.Context, taskName string, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSchemaListByTaskAndSourceResponse, error)

	// DMAPIGetTableListByTaskAndSource request
	DMAPIGetTableListByTaskAndSourceWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*DMAPIGetTableListByTaskAndSourceResponse, error)

	// DMAPIDeleteTableStructure request
	DMAPIDeleteTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTableStructureResponse, error)

	// DMAPIGetTableStructure request
	DMAPIGetTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*DMAPIGetTableStructureResponse, error)

	// DMAPIOperateTableStructure request with any body
	DMAPIOperateTableStructureWithBodyWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIOperateTableStructureResponse, error)

	DMAPIOperateTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, body DMAPIOperateTableStructureJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIOperateTableStructureResponse, error)

	// DMAPIStartTask request with any body
	DMAPIStartTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIStartTaskResponse, error)

	DMAPIStartTaskWithResponse(ctx context.Context, taskName string, body DMAPIStartTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIStartTaskResponse, error)

	// DMAPIGetTaskStatus request
	DMAPIGetTaskStatusWithResponse(ctx context.Context, taskName string, params *DMAPIGetTaskStatusParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskStatusResponse, error)

	// DMAPIStopTask request with any body
	DMAPIStopTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIStopTaskResponse, error)

	DMAPIStopTaskWithResponse(ctx context.Context, taskName string, body DMAPIStopTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIStopTaskResponse, error)
}

type DMAPIGetClusterInfoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetClusterInfoResponse
}

// Status returns HTTPResponse.Status
func (r DMAPIGetClusterInfoResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetClusterInfoResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIUpdateClusterInfoResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetClusterInfoResponse
}

// Status returns HTTPResponse.Status
func (r DMAPIUpdateClusterInfoResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIUpdateClusterInfoResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetClusterMasterListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetClusterMasterListResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetClusterMasterListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetClusterMasterListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIOfflineMasterNodeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIOfflineMasterNodeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIOfflineMasterNodeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetClusterWorkerListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetClusterWorkerListResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetClusterWorkerListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetClusterWorkerListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIOfflineWorkerNodeResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIOfflineWorkerNodeResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIOfflineWorkerNodeResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetDocJSONResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r GetDocJSONResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetDocJSONResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type GetDocHTMLResponse struct {
	Body         []byte
	HTTPResponse *http.Response
}

// Status returns HTTPResponse.Status
func (r GetDocHTMLResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r GetDocHTMLResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSourceListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetSourceListResponse
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSourceListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSourceListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPICreateSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Source
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPICreateSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPICreateSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDeleteSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDeleteSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDeleteSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Source
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIUpdateSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Source
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIUpdateSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIUpdateSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDisableSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDisableSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDisableSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIEnableSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIEnableSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIEnableSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDisableRelayResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDisableRelayResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDisableRelayResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIEnableRelayResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIEnableRelayResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIEnableRelayResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIPurgeRelayResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIPurgeRelayResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIPurgeRelayResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSourceSchemaListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SchemaNameList
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSourceSchemaListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSourceSchemaListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSourceTableListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TableNameList
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSourceTableListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSourceTableListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSourceStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetSourceStatusResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSourceStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSourceStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPITransferSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPITransferSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPITransferSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetTaskListResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPICreateTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *OperateTaskResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPICreateTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPICreateTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIConvertTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *ConverterTaskResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIConvertTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIConvertTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskTemplateListResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetTaskListResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskTemplateListResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskTemplateListResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPICreateTaskTemplateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON201      *Task
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPICreateTaskTemplateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPICreateTaskTemplateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIImportTaskTemplateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON202      *TaskTemplateResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIImportTaskTemplateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIImportTaskTemplateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDeleteTaskTemplateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDeleteTaskTemplateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDeleteTaskTemplateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskTemplateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Task
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskTemplateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskTemplateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPUpdateTaskTemplateResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Task
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPUpdateTaskTemplateResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPUpdateTaskTemplateResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDeleteTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDeleteTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDeleteTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *Task
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIUpdateTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *OperateTaskResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIUpdateTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIUpdateTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskMigrateTargetsResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetTaskMigrateTargetsResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskMigrateTargetsResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskMigrateTargetsResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetSchemaListByTaskAndSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *SchemaNameList
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetSchemaListByTaskAndSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetSchemaListByTaskAndSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTableListByTaskAndSourceResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *TableNameList
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTableListByTaskAndSourceResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTableListByTaskAndSourceResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIDeleteTableStructureResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIDeleteTableStructureResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIDeleteTableStructureResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTableStructureResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetTaskTableStructureResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTableStructureResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTableStructureResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIOperateTableStructureResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIOperateTableStructureResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIOperateTableStructureResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIStartTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIStartTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIStartTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIGetTaskStatusResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON200      *GetTaskStatusResponse
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIGetTaskStatusResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIGetTaskStatusResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

type DMAPIStopTaskResponse struct {
	Body         []byte
	HTTPResponse *http.Response
	JSON400      *ErrorWithMessage
}

// Status returns HTTPResponse.Status
func (r DMAPIStopTaskResponse) Status() string {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.Status
	}
	return http.StatusText(0)
}

// StatusCode returns HTTPResponse.StatusCode
func (r DMAPIStopTaskResponse) StatusCode() int {
	if r.HTTPResponse != nil {
		return r.HTTPResponse.StatusCode
	}
	return 0
}

// DMAPIGetClusterInfoWithResponse request returning *DMAPIGetClusterInfoResponse
func (c *ClientWithResponses) DMAPIGetClusterInfoWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterInfoResponse, error) {
	rsp, err := c.DMAPIGetClusterInfo(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetClusterInfoResponse(rsp)
}

// DMAPIUpdateClusterInfoWithBodyWithResponse request with arbitrary body returning *DMAPIUpdateClusterInfoResponse
func (c *ClientWithResponses) DMAPIUpdateClusterInfoWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateClusterInfoResponse, error) {
	rsp, err := c.DMAPIUpdateClusterInfoWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateClusterInfoResponse(rsp)
}

func (c *ClientWithResponses) DMAPIUpdateClusterInfoWithResponse(ctx context.Context, body DMAPIUpdateClusterInfoJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateClusterInfoResponse, error) {
	rsp, err := c.DMAPIUpdateClusterInfo(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateClusterInfoResponse(rsp)
}

// DMAPIGetClusterMasterListWithResponse request returning *DMAPIGetClusterMasterListResponse
func (c *ClientWithResponses) DMAPIGetClusterMasterListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterMasterListResponse, error) {
	rsp, err := c.DMAPIGetClusterMasterList(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetClusterMasterListResponse(rsp)
}

// DMAPIOfflineMasterNodeWithResponse request returning *DMAPIOfflineMasterNodeResponse
func (c *ClientWithResponses) DMAPIOfflineMasterNodeWithResponse(ctx context.Context, masterName string, reqEditors ...RequestEditorFn) (*DMAPIOfflineMasterNodeResponse, error) {
	rsp, err := c.DMAPIOfflineMasterNode(ctx, masterName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIOfflineMasterNodeResponse(rsp)
}

// DMAPIGetClusterWorkerListWithResponse request returning *DMAPIGetClusterWorkerListResponse
func (c *ClientWithResponses) DMAPIGetClusterWorkerListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetClusterWorkerListResponse, error) {
	rsp, err := c.DMAPIGetClusterWorkerList(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetClusterWorkerListResponse(rsp)
}

// DMAPIOfflineWorkerNodeWithResponse request returning *DMAPIOfflineWorkerNodeResponse
func (c *ClientWithResponses) DMAPIOfflineWorkerNodeWithResponse(ctx context.Context, workerName string, reqEditors ...RequestEditorFn) (*DMAPIOfflineWorkerNodeResponse, error) {
	rsp, err := c.DMAPIOfflineWorkerNode(ctx, workerName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIOfflineWorkerNodeResponse(rsp)
}

// GetDocJSONWithResponse request returning *GetDocJSONResponse
func (c *ClientWithResponses) GetDocJSONWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDocJSONResponse, error) {
	rsp, err := c.GetDocJSON(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDocJSONResponse(rsp)
}

// GetDocHTMLWithResponse request returning *GetDocHTMLResponse
func (c *ClientWithResponses) GetDocHTMLWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetDocHTMLResponse, error) {
	rsp, err := c.GetDocHTML(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseGetDocHTMLResponse(rsp)
}

// DMAPIGetSourceListWithResponse request returning *DMAPIGetSourceListResponse
func (c *ClientWithResponses) DMAPIGetSourceListWithResponse(ctx context.Context, params *DMAPIGetSourceListParams, reqEditors ...RequestEditorFn) (*DMAPIGetSourceListResponse, error) {
	rsp, err := c.DMAPIGetSourceList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSourceListResponse(rsp)
}

// DMAPICreateSourceWithBodyWithResponse request with arbitrary body returning *DMAPICreateSourceResponse
func (c *ClientWithResponses) DMAPICreateSourceWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateSourceResponse, error) {
	rsp, err := c.DMAPICreateSourceWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateSourceResponse(rsp)
}

func (c *ClientWithResponses) DMAPICreateSourceWithResponse(ctx context.Context, body DMAPICreateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateSourceResponse, error) {
	rsp, err := c.DMAPICreateSource(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateSourceResponse(rsp)
}

// DMAPIDeleteSourceWithResponse request returning *DMAPIDeleteSourceResponse
func (c *ClientWithResponses) DMAPIDeleteSourceWithResponse(ctx context.Context, sourceName string, params *DMAPIDeleteSourceParams, reqEditors ...RequestEditorFn) (*DMAPIDeleteSourceResponse, error) {
	rsp, err := c.DMAPIDeleteSource(ctx, sourceName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDeleteSourceResponse(rsp)
}

// DMAPIGetSourceWithResponse request returning *DMAPIGetSourceResponse
func (c *ClientWithResponses) DMAPIGetSourceWithResponse(ctx context.Context, sourceName string, params *DMAPIGetSourceParams, reqEditors ...RequestEditorFn) (*DMAPIGetSourceResponse, error) {
	rsp, err := c.DMAPIGetSource(ctx, sourceName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSourceResponse(rsp)
}

// DMAPIUpdateSourceWithBodyWithResponse request with arbitrary body returning *DMAPIUpdateSourceResponse
func (c *ClientWithResponses) DMAPIUpdateSourceWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateSourceResponse, error) {
	rsp, err := c.DMAPIUpdateSourceWithBody(ctx, sourceName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateSourceResponse(rsp)
}

func (c *ClientWithResponses) DMAPIUpdateSourceWithResponse(ctx context.Context, sourceName string, body DMAPIUpdateSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateSourceResponse, error) {
	rsp, err := c.DMAPIUpdateSource(ctx, sourceName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateSourceResponse(rsp)
}

// DMAPIDisableSourceWithResponse request returning *DMAPIDisableSourceResponse
func (c *ClientWithResponses) DMAPIDisableSourceWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIDisableSourceResponse, error) {
	rsp, err := c.DMAPIDisableSource(ctx, sourceName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDisableSourceResponse(rsp)
}

// DMAPIEnableSourceWithResponse request returning *DMAPIEnableSourceResponse
func (c *ClientWithResponses) DMAPIEnableSourceWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIEnableSourceResponse, error) {
	rsp, err := c.DMAPIEnableSource(ctx, sourceName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIEnableSourceResponse(rsp)
}

// DMAPIDisableRelayWithBodyWithResponse request with arbitrary body returning *DMAPIDisableRelayResponse
func (c *ClientWithResponses) DMAPIDisableRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIDisableRelayResponse, error) {
	rsp, err := c.DMAPIDisableRelayWithBody(ctx, sourceName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDisableRelayResponse(rsp)
}

func (c *ClientWithResponses) DMAPIDisableRelayWithResponse(ctx context.Context, sourceName string, body DMAPIDisableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIDisableRelayResponse, error) {
	rsp, err := c.DMAPIDisableRelay(ctx, sourceName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDisableRelayResponse(rsp)
}

// DMAPIEnableRelayWithBodyWithResponse request with arbitrary body returning *DMAPIEnableRelayResponse
func (c *ClientWithResponses) DMAPIEnableRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIEnableRelayResponse, error) {
	rsp, err := c.DMAPIEnableRelayWithBody(ctx, sourceName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIEnableRelayResponse(rsp)
}

func (c *ClientWithResponses) DMAPIEnableRelayWithResponse(ctx context.Context, sourceName string, body DMAPIEnableRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIEnableRelayResponse, error) {
	rsp, err := c.DMAPIEnableRelay(ctx, sourceName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIEnableRelayResponse(rsp)
}

// DMAPIPurgeRelayWithBodyWithResponse request with arbitrary body returning *DMAPIPurgeRelayResponse
func (c *ClientWithResponses) DMAPIPurgeRelayWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIPurgeRelayResponse, error) {
	rsp, err := c.DMAPIPurgeRelayWithBody(ctx, sourceName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIPurgeRelayResponse(rsp)
}

func (c *ClientWithResponses) DMAPIPurgeRelayWithResponse(ctx context.Context, sourceName string, body DMAPIPurgeRelayJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIPurgeRelayResponse, error) {
	rsp, err := c.DMAPIPurgeRelay(ctx, sourceName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIPurgeRelayResponse(rsp)
}

// DMAPIGetSourceSchemaListWithResponse request returning *DMAPIGetSourceSchemaListResponse
func (c *ClientWithResponses) DMAPIGetSourceSchemaListWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceSchemaListResponse, error) {
	rsp, err := c.DMAPIGetSourceSchemaList(ctx, sourceName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSourceSchemaListResponse(rsp)
}

// DMAPIGetSourceTableListWithResponse request returning *DMAPIGetSourceTableListResponse
func (c *ClientWithResponses) DMAPIGetSourceTableListWithResponse(ctx context.Context, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceTableListResponse, error) {
	rsp, err := c.DMAPIGetSourceTableList(ctx, sourceName, schemaName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSourceTableListResponse(rsp)
}

// DMAPIGetSourceStatusWithResponse request returning *DMAPIGetSourceStatusResponse
func (c *ClientWithResponses) DMAPIGetSourceStatusWithResponse(ctx context.Context, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSourceStatusResponse, error) {
	rsp, err := c.DMAPIGetSourceStatus(ctx, sourceName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSourceStatusResponse(rsp)
}

// DMAPITransferSourceWithBodyWithResponse request with arbitrary body returning *DMAPITransferSourceResponse
func (c *ClientWithResponses) DMAPITransferSourceWithBodyWithResponse(ctx context.Context, sourceName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPITransferSourceResponse, error) {
	rsp, err := c.DMAPITransferSourceWithBody(ctx, sourceName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPITransferSourceResponse(rsp)
}

func (c *ClientWithResponses) DMAPITransferSourceWithResponse(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPITransferSourceResponse, error) {
	rsp, err := c.DMAPITransferSource(ctx, sourceName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPITransferSourceResponse(rsp)
}

// DMAPIGetTaskListWithResponse request returning *DMAPIGetTaskListResponse
func (c *ClientWithResponses) DMAPIGetTaskListWithResponse(ctx context.Context, params *DMAPIGetTaskListParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskListResponse, error) {
	rsp, err := c.DMAPIGetTaskList(ctx, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskListResponse(rsp)
}

// DMAPICreateTaskWithBodyWithResponse request with arbitrary body returning *DMAPICreateTaskResponse
func (c *ClientWithResponses) DMAPICreateTaskWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskResponse, error) {
	rsp, err := c.DMAPICreateTaskWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateTaskResponse(rsp)
}

func (c *ClientWithResponses) DMAPICreateTaskWithResponse(ctx context.Context, body DMAPICreateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskResponse, error) {
	rsp, err := c.DMAPICreateTask(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateTaskResponse(rsp)
}

// DMAPIConvertTaskWithBodyWithResponse request with arbitrary body returning *DMAPIConvertTaskResponse
func (c *ClientWithResponses) DMAPIConvertTaskWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIConvertTaskResponse, error) {
	rsp, err := c.DMAPIConvertTaskWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIConvertTaskResponse(rsp)
}

func (c *ClientWithResponses) DMAPIConvertTaskWithResponse(ctx context.Context, body DMAPIConvertTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIConvertTaskResponse, error) {
	rsp, err := c.DMAPIConvertTask(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIConvertTaskResponse(rsp)
}

// DMAPIGetTaskTemplateListWithResponse request returning *DMAPIGetTaskTemplateListResponse
func (c *ClientWithResponses) DMAPIGetTaskTemplateListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskTemplateListResponse, error) {
	rsp, err := c.DMAPIGetTaskTemplateList(ctx, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskTemplateListResponse(rsp)
}

// DMAPICreateTaskTemplateWithBodyWithResponse request with arbitrary body returning *DMAPICreateTaskTemplateResponse
func (c *ClientWithResponses) DMAPICreateTaskTemplateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskTemplateResponse, error) {
	rsp, err := c.DMAPICreateTaskTemplateWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateTaskTemplateResponse(rsp)
}

func (c *ClientWithResponses) DMAPICreateTaskTemplateWithResponse(ctx context.Context, body DMAPICreateTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskTemplateResponse, error) {
	rsp, err := c.DMAPICreateTaskTemplate(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPICreateTaskTemplateResponse(rsp)
}

// DMAPIImportTaskTemplateWithBodyWithResponse request with arbitrary body returning *DMAPIImportTaskTemplateResponse
func (c *ClientWithResponses) DMAPIImportTaskTemplateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIImportTaskTemplateResponse, error) {
	rsp, err := c.DMAPIImportTaskTemplateWithBody(ctx, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIImportTaskTemplateResponse(rsp)
}

func (c *ClientWithResponses) DMAPIImportTaskTemplateWithResponse(ctx context.Context, body DMAPIImportTaskTemplateJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIImportTaskTemplateResponse, error) {
	rsp, err := c.DMAPIImportTaskTemplate(ctx, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIImportTaskTemplateResponse(rsp)
}

// DMAPIDeleteTaskTemplateWithResponse request returning *DMAPIDeleteTaskTemplateResponse
func (c *ClientWithResponses) DMAPIDeleteTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskTemplateResponse, error) {
	rsp, err := c.DMAPIDeleteTaskTemplate(ctx, taskName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDeleteTaskTemplateResponse(rsp)
}

// DMAPIGetTaskTemplateWithResponse request returning *DMAPIGetTaskTemplateResponse
func (c *ClientWithResponses) DMAPIGetTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIGetTaskTemplateResponse, error) {
	rsp, err := c.DMAPIGetTaskTemplate(ctx, taskName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskTemplateResponse(rsp)
}

// DMAPUpdateTaskTemplateWithResponse request returning *DMAPUpdateTaskTemplateResponse
func (c *ClientWithResponses) DMAPUpdateTaskTemplateWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPUpdateTaskTemplateResponse, error) {
	rsp, err := c.DMAPUpdateTaskTemplate(ctx, taskName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPUpdateTaskTemplateResponse(rsp)
}

// DMAPIDeleteTaskWithResponse request returning *DMAPIDeleteTaskResponse
func (c *ClientWithResponses) DMAPIDeleteTaskWithResponse(ctx context.Context, taskName string, params *DMAPIDeleteTaskParams, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskResponse, error) {
	rsp, err := c.DMAPIDeleteTask(ctx, taskName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDeleteTaskResponse(rsp)
}

// DMAPIGetTaskWithResponse request returning *DMAPIGetTaskResponse
func (c *ClientWithResponses) DMAPIGetTaskWithResponse(ctx context.Context, taskName string, params *DMAPIGetTaskParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskResponse, error) {
	rsp, err := c.DMAPIGetTask(ctx, taskName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskResponse(rsp)
}

// DMAPIUpdateTaskWithBodyWithResponse request with arbitrary body returning *DMAPIUpdateTaskResponse
func (c *ClientWithResponses) DMAPIUpdateTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIUpdateTaskResponse, error) {
	rsp, err := c.DMAPIUpdateTaskWithBody(ctx, taskName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateTaskResponse(rsp)
}

func (c *ClientWithResponses) DMAPIUpdateTaskWithResponse(ctx context.Context, taskName string, body DMAPIUpdateTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIUpdateTaskResponse, error) {
	rsp, err := c.DMAPIUpdateTask(ctx, taskName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIUpdateTaskResponse(rsp)
}

// DMAPIGetTaskMigrateTargetsWithResponse request returning *DMAPIGetTaskMigrateTargetsResponse
func (c *ClientWithResponses) DMAPIGetTaskMigrateTargetsWithResponse(ctx context.Context, taskName string, sourceName string, params *DMAPIGetTaskMigrateTargetsParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskMigrateTargetsResponse, error) {
	rsp, err := c.DMAPIGetTaskMigrateTargets(ctx, taskName, sourceName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskMigrateTargetsResponse(rsp)
}

// DMAPIGetSchemaListByTaskAndSourceWithResponse request returning *DMAPIGetSchemaListByTaskAndSourceResponse
func (c *ClientWithResponses) DMAPIGetSchemaListByTaskAndSourceWithResponse(ctx context.Context, taskName string, sourceName string, reqEditors ...RequestEditorFn) (*DMAPIGetSchemaListByTaskAndSourceResponse, error) {
	rsp, err := c.DMAPIGetSchemaListByTaskAndSource(ctx, taskName, sourceName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetSchemaListByTaskAndSourceResponse(rsp)
}

// DMAPIGetTableListByTaskAndSourceWithResponse request returning *DMAPIGetTableListByTaskAndSourceResponse
func (c *ClientWithResponses) DMAPIGetTableListByTaskAndSourceWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, reqEditors ...RequestEditorFn) (*DMAPIGetTableListByTaskAndSourceResponse, error) {
	rsp, err := c.DMAPIGetTableListByTaskAndSource(ctx, taskName, sourceName, schemaName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTableListByTaskAndSourceResponse(rsp)
}

// DMAPIDeleteTableStructureWithResponse request returning *DMAPIDeleteTableStructureResponse
func (c *ClientWithResponses) DMAPIDeleteTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTableStructureResponse, error) {
	rsp, err := c.DMAPIDeleteTableStructure(ctx, taskName, sourceName, schemaName, tableName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIDeleteTableStructureResponse(rsp)
}

// DMAPIGetTableStructureWithResponse request returning *DMAPIGetTableStructureResponse
func (c *ClientWithResponses) DMAPIGetTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, reqEditors ...RequestEditorFn) (*DMAPIGetTableStructureResponse, error) {
	rsp, err := c.DMAPIGetTableStructure(ctx, taskName, sourceName, schemaName, tableName, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTableStructureResponse(rsp)
}

// DMAPIOperateTableStructureWithBodyWithResponse request with arbitrary body returning *DMAPIOperateTableStructureResponse
func (c *ClientWithResponses) DMAPIOperateTableStructureWithBodyWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIOperateTableStructureResponse, error) {
	rsp, err := c.DMAPIOperateTableStructureWithBody(ctx, taskName, sourceName, schemaName, tableName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIOperateTableStructureResponse(rsp)
}

func (c *ClientWithResponses) DMAPIOperateTableStructureWithResponse(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string, body DMAPIOperateTableStructureJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIOperateTableStructureResponse, error) {
	rsp, err := c.DMAPIOperateTableStructure(ctx, taskName, sourceName, schemaName, tableName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIOperateTableStructureResponse(rsp)
}

// DMAPIStartTaskWithBodyWithResponse request with arbitrary body returning *DMAPIStartTaskResponse
func (c *ClientWithResponses) DMAPIStartTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIStartTaskResponse, error) {
	rsp, err := c.DMAPIStartTaskWithBody(ctx, taskName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIStartTaskResponse(rsp)
}

func (c *ClientWithResponses) DMAPIStartTaskWithResponse(ctx context.Context, taskName string, body DMAPIStartTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIStartTaskResponse, error) {
	rsp, err := c.DMAPIStartTask(ctx, taskName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIStartTaskResponse(rsp)
}

// DMAPIGetTaskStatusWithResponse request returning *DMAPIGetTaskStatusResponse
func (c *ClientWithResponses) DMAPIGetTaskStatusWithResponse(ctx context.Context, taskName string, params *DMAPIGetTaskStatusParams, reqEditors ...RequestEditorFn) (*DMAPIGetTaskStatusResponse, error) {
	rsp, err := c.DMAPIGetTaskStatus(ctx, taskName, params, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIGetTaskStatusResponse(rsp)
}

// DMAPIStopTaskWithBodyWithResponse request with arbitrary body returning *DMAPIStopTaskResponse
func (c *ClientWithResponses) DMAPIStopTaskWithBodyWithResponse(ctx context.Context, taskName string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIStopTaskResponse, error) {
	rsp, err := c.DMAPIStopTaskWithBody(ctx, taskName, contentType, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIStopTaskResponse(rsp)
}

func (c *ClientWithResponses) DMAPIStopTaskWithResponse(ctx context.Context, taskName string, body DMAPIStopTaskJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIStopTaskResponse, error) {
	rsp, err := c.DMAPIStopTask(ctx, taskName, body, reqEditors...)
	if err != nil {
		return nil, err
	}
	return ParseDMAPIStopTaskResponse(rsp)
}

// ParseDMAPIGetClusterInfoResponse parses an HTTP response from a DMAPIGetClusterInfoWithResponse call
func ParseDMAPIGetClusterInfoResponse(rsp *http.Response) (*DMAPIGetClusterInfoResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetClusterInfoResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetClusterInfoResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest
	}

	return response, nil
}

// ParseDMAPIUpdateClusterInfoResponse parses an HTTP response from a DMAPIUpdateClusterInfoWithResponse call
func ParseDMAPIUpdateClusterInfoResponse(rsp *http.Response) (*DMAPIUpdateClusterInfoResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIUpdateClusterInfoResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetClusterInfoResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest
	}

	return response, nil
}

// ParseDMAPIGetClusterMasterListResponse parses an HTTP response from a DMAPIGetClusterMasterListWithResponse call
func ParseDMAPIGetClusterMasterListResponse(rsp *http.Response) (*DMAPIGetClusterMasterListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetClusterMasterListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetClusterMasterListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIOfflineMasterNodeResponse parses an HTTP response from a DMAPIOfflineMasterNodeWithResponse call
func ParseDMAPIOfflineMasterNodeResponse(rsp *http.Response) (*DMAPIOfflineMasterNodeResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIOfflineMasterNodeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetClusterWorkerListResponse parses an HTTP response from a DMAPIGetClusterWorkerListWithResponse call
func ParseDMAPIGetClusterWorkerListResponse(rsp *http.Response) (*DMAPIGetClusterWorkerListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetClusterWorkerListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetClusterWorkerListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIOfflineWorkerNodeResponse parses an HTTP response from a DMAPIOfflineWorkerNodeWithResponse call
func ParseDMAPIOfflineWorkerNodeResponse(rsp *http.Response) (*DMAPIOfflineWorkerNodeResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIOfflineWorkerNodeResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseGetDocJSONResponse parses an HTTP response from a GetDocJSONWithResponse call
func ParseGetDocJSONResponse(rsp *http.Response) (*GetDocJSONResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetDocJSONResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseGetDocHTMLResponse parses an HTTP response from a GetDocHTMLWithResponse call
func ParseGetDocHTMLResponse(rsp *http.Response) (*GetDocHTMLResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &GetDocHTMLResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	return response, nil
}

// ParseDMAPIGetSourceListResponse parses an HTTP response from a DMAPIGetSourceListWithResponse call
func ParseDMAPIGetSourceListResponse(rsp *http.Response) (*DMAPIGetSourceListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSourceListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetSourceListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest
	}

	return response, nil
}

// ParseDMAPICreateSourceResponse parses an HTTP response from a DMAPICreateSourceWithResponse call
func ParseDMAPICreateSourceResponse(rsp *http.Response) (*DMAPICreateSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPICreateSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Source
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIDeleteSourceResponse parses an HTTP response from a DMAPIDeleteSourceWithResponse call
func ParseDMAPIDeleteSourceResponse(rsp *http.Response) (*DMAPIDeleteSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDeleteSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetSourceResponse parses an HTTP response from a DMAPIGetSourceWithResponse call
func ParseDMAPIGetSourceResponse(rsp *http.Response) (*DMAPIGetSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Source
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest
	}

	return response, nil
}

// ParseDMAPIUpdateSourceResponse parses an HTTP response from a DMAPIUpdateSourceWithResponse call
func ParseDMAPIUpdateSourceResponse(rsp *http.Response) (*DMAPIUpdateSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIUpdateSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Source
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIDisableSourceResponse parses an HTTP response from a DMAPIDisableSourceWithResponse call
func ParseDMAPIDisableSourceResponse(rsp *http.Response) (*DMAPIDisableSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDisableSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIEnableSourceResponse parses an HTTP response from a DMAPIEnableSourceWithResponse call
func ParseDMAPIEnableSourceResponse(rsp *http.Response) (*DMAPIEnableSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIEnableSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIDisableRelayResponse parses an HTTP response from a DMAPIDisableRelayWithResponse call
func ParseDMAPIDisableRelayResponse(rsp *http.Response) (*DMAPIDisableRelayResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDisableRelayResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIEnableRelayResponse parses an HTTP response from a DMAPIEnableRelayWithResponse call
func ParseDMAPIEnableRelayResponse(rsp *http.Response) (*DMAPIEnableRelayResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIEnableRelayResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIPurgeRelayResponse parses an HTTP response from a DMAPIPurgeRelayWithResponse call
func ParseDMAPIPurgeRelayResponse(rsp *http.Response) (*DMAPIPurgeRelayResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIPurgeRelayResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetSourceSchemaListResponse parses an HTTP response from a DMAPIGetSourceSchemaListWithResponse call
func ParseDMAPIGetSourceSchemaListResponse(rsp *http.Response) (*DMAPIGetSourceSchemaListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSourceSchemaListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SchemaNameList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetSourceTableListResponse parses an HTTP response from a DMAPIGetSourceTableListWithResponse call
func ParseDMAPIGetSourceTableListResponse(rsp *http.Response) (*DMAPIGetSourceTableListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSourceTableListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TableNameList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetSourceStatusResponse parses an HTTP response from a DMAPIGetSourceStatusWithResponse call
func ParseDMAPIGetSourceStatusResponse(rsp *http.Response) (*DMAPIGetSourceStatusResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSourceStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetSourceStatusResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPITransferSourceResponse parses an HTTP response from a DMAPITransferSourceWithResponse call
func ParseDMAPITransferSourceResponse(rsp *http.Response) (*DMAPITransferSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPITransferSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetTaskListResponse parses an HTTP response from a DMAPIGetTaskListWithResponse call
func ParseDMAPIGetTaskListResponse(rsp *http.Response) (*DMAPIGetTaskListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetTaskListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPICreateTaskResponse parses an HTTP response from a DMAPICreateTaskWithResponse call
func ParseDMAPICreateTaskResponse(rsp *http.Response) (*DMAPICreateTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPICreateTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest OperateTaskResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIConvertTaskResponse parses an HTTP response from a DMAPIConvertTaskWithResponse call
func ParseDMAPIConvertTaskResponse(rsp *http.Response) (*DMAPIConvertTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIConvertTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest ConverterTaskResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetTaskTemplateListResponse parses an HTTP response from a DMAPIGetTaskTemplateListWithResponse call
func ParseDMAPIGetTaskTemplateListResponse(rsp *http.Response) (*DMAPIGetTaskTemplateListResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskTemplateListResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetTaskListResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPICreateTaskTemplateResponse parses an HTTP response from a DMAPICreateTaskTemplateWithResponse call
func ParseDMAPICreateTaskTemplateResponse(rsp *http.Response) (*DMAPICreateTaskTemplateResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPICreateTaskTemplateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201:
		var dest Task
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON201 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIImportTaskTemplateResponse parses an HTTP response from a DMAPIImportTaskTemplateWithResponse call
func ParseDMAPIImportTaskTemplateResponse(rsp *http.Response) (*DMAPIImportTaskTemplateResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIImportTaskTemplateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 202:
		var dest TaskTemplateResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON202 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIDeleteTaskTemplateResponse parses an HTTP response from a DMAPIDeleteTaskTemplateWithResponse call
func ParseDMAPIDeleteTaskTemplateResponse(rsp *http.Response) (*DMAPIDeleteTaskTemplateResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDeleteTaskTemplateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetTaskTemplateResponse parses an HTTP response from a DMAPIGetTaskTemplateWithResponse call
func ParseDMAPIGetTaskTemplateResponse(rsp *http.Response) (*DMAPIGetTaskTemplateResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskTemplateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Task
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPUpdateTaskTemplateResponse parses an HTTP response from a DMAPUpdateTaskTemplateWithResponse call
func ParseDMAPUpdateTaskTemplateResponse(rsp *http.Response) (*DMAPUpdateTaskTemplateResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPUpdateTaskTemplateResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Task
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIDeleteTaskResponse parses an HTTP response from a DMAPIDeleteTaskWithResponse call
func ParseDMAPIDeleteTaskResponse(rsp *http.Response) (*DMAPIDeleteTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDeleteTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetTaskResponse parses an HTTP response from a DMAPIGetTaskWithResponse call
func ParseDMAPIGetTaskResponse(rsp *http.Response) (*DMAPIGetTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest Task
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest
	}

	return response, nil
}

// ParseDMAPIUpdateTaskResponse parses an HTTP response from a DMAPIUpdateTaskWithResponse call
func ParseDMAPIUpdateTaskResponse(rsp *http.Response) (*DMAPIUpdateTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIUpdateTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest OperateTaskResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetTaskMigrateTargetsResponse parses an HTTP response from a DMAPIGetTaskMigrateTargetsWithResponse call
func ParseDMAPIGetTaskMigrateTargetsResponse(rsp *http.Response) (*DMAPIGetTaskMigrateTargetsResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskMigrateTargetsResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetTaskMigrateTargetsResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetSchemaListByTaskAndSourceResponse parses an HTTP response from a DMAPIGetSchemaListByTaskAndSourceWithResponse call
func ParseDMAPIGetSchemaListByTaskAndSourceResponse(rsp *http.Response) (*DMAPIGetSchemaListByTaskAndSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetSchemaListByTaskAndSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest SchemaNameList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIGetTableListByTaskAndSourceResponse parses an HTTP response from a DMAPIGetTableListByTaskAndSourceWithResponse call
func ParseDMAPIGetTableListByTaskAndSourceResponse(rsp *http.Response) (*DMAPIGetTableListByTaskAndSourceResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTableListByTaskAndSourceResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest TableNameList
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIDeleteTableStructureResponse parses an HTTP response from a DMAPIDeleteTableStructureWithResponse call
func ParseDMAPIDeleteTableStructureResponse(rsp *http.Response) (*DMAPIDeleteTableStructureResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIDeleteTableStructureResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetTableStructureResponse parses an HTTP response from a DMAPIGetTableStructureWithResponse call
func ParseDMAPIGetTableStructureResponse(rsp *http.Response) (*DMAPIGetTableStructureResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTableStructureResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetTaskTableStructureResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIOperateTableStructureResponse parses an HTTP response from a DMAPIOperateTableStructureWithResponse call
func ParseDMAPIOperateTableStructureResponse(rsp *http.Response) (*DMAPIOperateTableStructureResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIOperateTableStructureResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIStartTaskResponse parses an HTTP response from a DMAPIStartTaskWithResponse call
func ParseDMAPIStartTaskResponse(rsp *http.Response) (*DMAPIStartTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIStartTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}

// ParseDMAPIGetTaskStatusResponse parses an HTTP response from a DMAPIGetTaskStatusWithResponse call
func ParseDMAPIGetTaskStatusResponse(rsp *http.Response) (*DMAPIGetTaskStatusResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIGetTaskStatusResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
		var dest GetTaskStatusResponse
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON200 = &dest

	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest

	}

	return response, nil
}

// ParseDMAPIStopTaskResponse parses an HTTP response from a DMAPIStopTaskWithResponse call
func ParseDMAPIStopTaskResponse(rsp *http.Response) (*DMAPIStopTaskResponse, error) {
	bodyBytes, err := ioutil.ReadAll(rsp.Body)
	defer func() { _ = rsp.Body.Close() }()
	if err != nil {
		return nil, err
	}

	response := &DMAPIStopTaskResponse{
		Body:         bodyBytes,
		HTTPResponse: rsp,
	}

	switch {
	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
		var dest ErrorWithMessage
		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
			return nil, err
		}
		response.JSON400 = &dest
	}

	return response, nil
}