/*
DM OpenAPI DOC

No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

API version: 6.0.0
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package dm

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"reflect"
	"strings"
)

// TaskAPIService TaskAPI service
type TaskAPIService service

type ApiDMAPIConvertTaskRequest struct {
	ctx                  context.Context
	ApiService           *TaskAPIService
	converterTaskRequest *ConverterTaskRequest
}

// if task is input this task will be converted to task_config file or vice versa
func (r ApiDMAPIConvertTaskRequest) ConverterTaskRequest(converterTaskRequest ConverterTaskRequest) ApiDMAPIConvertTaskRequest {
	r.converterTaskRequest = &converterTaskRequest
	return r
}

func (r ApiDMAPIConvertTaskRequest) Execute() (*ConverterTaskResponse, *http.Response, error) {
	return r.ApiService.DMAPIConvertTaskExecute(r)
}

/*
DMAPIConvertTask Turn task into the format of a configuration file or vice versa.

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPIConvertTaskRequest
*/
func (a *TaskAPIService) DMAPIConvertTask(ctx context.Context) ApiDMAPIConvertTaskRequest {
	return ApiDMAPIConvertTaskRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return ConverterTaskResponse
func (a *TaskAPIService) DMAPIConvertTaskExecute(r ApiDMAPIConvertTaskRequest) (*ConverterTaskResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *ConverterTaskResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIConvertTask")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/converters"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.converterTaskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPICreateTaskRequest struct {
	ctx               context.Context
	ApiService        *TaskAPIService
	createTaskRequest *CreateTaskRequest
}

// request body
func (r ApiDMAPICreateTaskRequest) CreateTaskRequest(createTaskRequest CreateTaskRequest) ApiDMAPICreateTaskRequest {
	r.createTaskRequest = &createTaskRequest
	return r
}

func (r ApiDMAPICreateTaskRequest) Execute() (*OperateTaskResponse, *http.Response, error) {
	return r.ApiService.DMAPICreateTaskExecute(r)
}

/*
DMAPICreateTask create a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPICreateTaskRequest
*/
func (a *TaskAPIService) DMAPICreateTask(ctx context.Context) ApiDMAPICreateTaskRequest {
	return ApiDMAPICreateTaskRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return OperateTaskResponse
func (a *TaskAPIService) DMAPICreateTaskExecute(r ApiDMAPICreateTaskRequest) (*OperateTaskResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *OperateTaskResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPICreateTask")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.createTaskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPICreateTaskTemplateRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	task       *Task
}

// request body
func (r ApiDMAPICreateTaskTemplateRequest) Task(task Task) ApiDMAPICreateTaskTemplateRequest {
	r.task = &task
	return r
}

func (r ApiDMAPICreateTaskTemplateRequest) Execute() (*Task, *http.Response, error) {
	return r.ApiService.DMAPICreateTaskTemplateExecute(r)
}

/*
DMAPICreateTaskTemplate create task template

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPICreateTaskTemplateRequest
*/
func (a *TaskAPIService) DMAPICreateTaskTemplate(ctx context.Context) ApiDMAPICreateTaskTemplateRequest {
	return ApiDMAPICreateTaskTemplateRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return Task
func (a *TaskAPIService) DMAPICreateTaskTemplateExecute(r ApiDMAPICreateTaskTemplateRequest) (*Task, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *Task
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPICreateTaskTemplate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.task
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIDeleteTableStructureRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	sourceName string
	schemaName string
	tableName  string
}

func (r ApiDMAPIDeleteTableStructureRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIDeleteTableStructureExecute(r)
}

/*
DMAPIDeleteTableStructure delete task source table structure

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@param schemaName schema name
	@param tableName table name
	@return ApiDMAPIDeleteTableStructureRequest
*/
func (a *TaskAPIService) DMAPIDeleteTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string) ApiDMAPIDeleteTableStructureRequest {
	return ApiDMAPIDeleteTableStructureRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
		schemaName: schemaName,
		tableName:  tableName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIDeleteTableStructureExecute(r ApiDMAPIDeleteTableStructureRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodDelete
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIDeleteTableStructure")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"schema-name"+"}", url.PathEscape(parameterValueToString(r.schemaName, "schemaName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"table-name"+"}", url.PathEscape(parameterValueToString(r.tableName, "tableName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIDeleteTaskRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	force      *bool
}

// force stop task even if some subtask is running
func (r ApiDMAPIDeleteTaskRequest) Force(force bool) ApiDMAPIDeleteTaskRequest {
	r.force = &force
	return r
}

func (r ApiDMAPIDeleteTaskRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIDeleteTaskExecute(r)
}

/*
DMAPIDeleteTask delete a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIDeleteTaskRequest
*/
func (a *TaskAPIService) DMAPIDeleteTask(ctx context.Context, taskName string) ApiDMAPIDeleteTaskRequest {
	return ApiDMAPIDeleteTaskRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIDeleteTaskExecute(r ApiDMAPIDeleteTaskRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodDelete
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIDeleteTask")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.force != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "force", r.force, "form", "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIDeleteTaskTemplateRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
}

func (r ApiDMAPIDeleteTaskTemplateRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIDeleteTaskTemplateExecute(r)
}

/*
DMAPIDeleteTaskTemplate delete task template template

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIDeleteTaskTemplateRequest
*/
func (a *TaskAPIService) DMAPIDeleteTaskTemplate(ctx context.Context, taskName string) ApiDMAPIDeleteTaskTemplateRequest {
	return ApiDMAPIDeleteTaskTemplateRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIDeleteTaskTemplateExecute(r ApiDMAPIDeleteTaskTemplateRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodDelete
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIDeleteTaskTemplate")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIGetSchemaListByTaskAndSourceRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	sourceName string
}

func (r ApiDMAPIGetSchemaListByTaskAndSourceRequest) Execute() ([]string, *http.Response, error) {
	return r.ApiService.DMAPIGetSchemaListByTaskAndSourceExecute(r)
}

/*
DMAPIGetSchemaListByTaskAndSource get task source schema list

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@return ApiDMAPIGetSchemaListByTaskAndSourceRequest
*/
func (a *TaskAPIService) DMAPIGetSchemaListByTaskAndSource(ctx context.Context, taskName string, sourceName string) ApiDMAPIGetSchemaListByTaskAndSourceRequest {
	return ApiDMAPIGetSchemaListByTaskAndSourceRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
	}
}

// Execute executes the request
//
//	@return []string
func (a *TaskAPIService) DMAPIGetSchemaListByTaskAndSourceExecute(r ApiDMAPIGetSchemaListByTaskAndSourceRequest) ([]string, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []string
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetSchemaListByTaskAndSource")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/schemas"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTableListByTaskAndSourceRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	sourceName string
	schemaName string
}

func (r ApiDMAPIGetTableListByTaskAndSourceRequest) Execute() ([]string, *http.Response, error) {
	return r.ApiService.DMAPIGetTableListByTaskAndSourceExecute(r)
}

/*
DMAPIGetTableListByTaskAndSource get task source table list

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@param schemaName schema name
	@return ApiDMAPIGetTableListByTaskAndSourceRequest
*/
func (a *TaskAPIService) DMAPIGetTableListByTaskAndSource(ctx context.Context, taskName string, sourceName string, schemaName string) ApiDMAPIGetTableListByTaskAndSourceRequest {
	return ApiDMAPIGetTableListByTaskAndSourceRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
		schemaName: schemaName,
	}
}

// Execute executes the request
//
//	@return []string
func (a *TaskAPIService) DMAPIGetTableListByTaskAndSourceExecute(r ApiDMAPIGetTableListByTaskAndSourceRequest) ([]string, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue []string
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTableListByTaskAndSource")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"schema-name"+"}", url.PathEscape(parameterValueToString(r.schemaName, "schemaName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTableStructureRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	sourceName string
	schemaName string
	tableName  string
}

func (r ApiDMAPIGetTableStructureRequest) Execute() (*GetTaskTableStructureResponse, *http.Response, error) {
	return r.ApiService.DMAPIGetTableStructureExecute(r)
}

/*
DMAPIGetTableStructure get task source table structure

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@param schemaName schema name
	@param tableName table name
	@return ApiDMAPIGetTableStructureRequest
*/
func (a *TaskAPIService) DMAPIGetTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string) ApiDMAPIGetTableStructureRequest {
	return ApiDMAPIGetTableStructureRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
		schemaName: schemaName,
		tableName:  tableName,
	}
}

// Execute executes the request
//
//	@return GetTaskTableStructureResponse
func (a *TaskAPIService) DMAPIGetTableStructureExecute(r ApiDMAPIGetTableStructureRequest) (*GetTaskTableStructureResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *GetTaskTableStructureResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTableStructure")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"schema-name"+"}", url.PathEscape(parameterValueToString(r.schemaName, "schemaName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"table-name"+"}", url.PathEscape(parameterValueToString(r.tableName, "tableName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
	withStatus *bool
}

// get task with status
func (r ApiDMAPIGetTaskRequest) WithStatus(withStatus bool) ApiDMAPIGetTaskRequest {
	r.withStatus = &withStatus
	return r
}

func (r ApiDMAPIGetTaskRequest) Execute() (*Task, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskExecute(r)
}

/*
DMAPIGetTask get a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIGetTaskRequest
*/
func (a *TaskAPIService) DMAPIGetTask(ctx context.Context, taskName string) ApiDMAPIGetTaskRequest {
	return ApiDMAPIGetTaskRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
//
//	@return Task
func (a *TaskAPIService) DMAPIGetTaskExecute(r ApiDMAPIGetTaskRequest) (*Task, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *Task
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTask")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.withStatus != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "with_status", r.withStatus, "form", "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskListRequest struct {
	ctx            context.Context
	ApiService     *TaskAPIService
	withStatus     *bool
	stage          *TaskStage
	sourceNameList *[]string
}

// get task with status
func (r ApiDMAPIGetTaskListRequest) WithStatus(withStatus bool) ApiDMAPIGetTaskListRequest {
	r.withStatus = &withStatus
	return r
}

// filter by task stage
func (r ApiDMAPIGetTaskListRequest) Stage(stage TaskStage) ApiDMAPIGetTaskListRequest {
	r.stage = &stage
	return r
}

// filter by source name
func (r ApiDMAPIGetTaskListRequest) SourceNameList(sourceNameList []string) ApiDMAPIGetTaskListRequest {
	r.sourceNameList = &sourceNameList
	return r
}

func (r ApiDMAPIGetTaskListRequest) Execute() (*GetTaskListResponse, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskListExecute(r)
}

/*
DMAPIGetTaskList get task list

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPIGetTaskListRequest
*/
func (a *TaskAPIService) DMAPIGetTaskList(ctx context.Context) ApiDMAPIGetTaskListRequest {
	return ApiDMAPIGetTaskListRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return GetTaskListResponse
func (a *TaskAPIService) DMAPIGetTaskListExecute(r ApiDMAPIGetTaskListRequest) (*GetTaskListResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *GetTaskListResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTaskList")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.withStatus != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "with_status", r.withStatus, "form", "")
	}
	if r.stage != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "stage", r.stage, "form", "")
	}
	if r.sourceNameList != nil {
		t := *r.sourceNameList
		if reflect.TypeOf(t).Kind() == reflect.Slice {
			s := reflect.ValueOf(t)
			for i := 0; i < s.Len(); i++ {
				parameterAddToHeaderOrQuery(localVarQueryParams, "source_name_list", s.Index(i).Interface(), "form", "multi")
			}
		} else {
			parameterAddToHeaderOrQuery(localVarQueryParams, "source_name_list", t, "form", "multi")
		}
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskMigrateTargetsRequest struct {
	ctx           context.Context
	ApiService    *TaskAPIService
	taskName      string
	sourceName    string
	schemaPattern *string
	tablePattern  *string
}

func (r ApiDMAPIGetTaskMigrateTargetsRequest) SchemaPattern(schemaPattern string) ApiDMAPIGetTaskMigrateTargetsRequest {
	r.schemaPattern = &schemaPattern
	return r
}

func (r ApiDMAPIGetTaskMigrateTargetsRequest) TablePattern(tablePattern string) ApiDMAPIGetTaskMigrateTargetsRequest {
	r.tablePattern = &tablePattern
	return r
}

func (r ApiDMAPIGetTaskMigrateTargetsRequest) Execute() (*GetTaskMigrateTargetsResponse, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskMigrateTargetsExecute(r)
}

/*
DMAPIGetTaskMigrateTargets get task source table and target table route relation

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@return ApiDMAPIGetTaskMigrateTargetsRequest
*/
func (a *TaskAPIService) DMAPIGetTaskMigrateTargets(ctx context.Context, taskName string, sourceName string) ApiDMAPIGetTaskMigrateTargetsRequest {
	return ApiDMAPIGetTaskMigrateTargetsRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
	}
}

// Execute executes the request
//
//	@return GetTaskMigrateTargetsResponse
func (a *TaskAPIService) DMAPIGetTaskMigrateTargetsExecute(r ApiDMAPIGetTaskMigrateTargetsRequest) (*GetTaskMigrateTargetsResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *GetTaskMigrateTargetsResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTaskMigrateTargets")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/migrate_targets"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.schemaPattern != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "schema_pattern", r.schemaPattern, "form", "")
	}
	if r.tablePattern != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "table_pattern", r.tablePattern, "form", "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskStatusRequest struct {
	ctx            context.Context
	ApiService     *TaskAPIService
	taskName       string
	sourceNameList *[]string
}

// source name list
func (r ApiDMAPIGetTaskStatusRequest) SourceNameList(sourceNameList []string) ApiDMAPIGetTaskStatusRequest {
	r.sourceNameList = &sourceNameList
	return r
}

func (r ApiDMAPIGetTaskStatusRequest) Execute() (*GetTaskStatusResponse, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskStatusExecute(r)
}

/*
DMAPIGetTaskStatus get task status

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIGetTaskStatusRequest
*/
func (a *TaskAPIService) DMAPIGetTaskStatus(ctx context.Context, taskName string) ApiDMAPIGetTaskStatusRequest {
	return ApiDMAPIGetTaskStatusRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
//
//	@return GetTaskStatusResponse
func (a *TaskAPIService) DMAPIGetTaskStatusExecute(r ApiDMAPIGetTaskStatusRequest) (*GetTaskStatusResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *GetTaskStatusResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTaskStatus")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/status"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.sourceNameList != nil {
		t := *r.sourceNameList
		if reflect.TypeOf(t).Kind() == reflect.Slice {
			s := reflect.ValueOf(t)
			for i := 0; i < s.Len(); i++ {
				parameterAddToHeaderOrQuery(localVarQueryParams, "source_name_list", s.Index(i).Interface(), "form", "multi")
			}
		} else {
			parameterAddToHeaderOrQuery(localVarQueryParams, "source_name_list", t, "form", "multi")
		}
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskTemplateRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
}

func (r ApiDMAPIGetTaskTemplateRequest) Execute() (*Task, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskTemplateExecute(r)
}

/*
DMAPIGetTaskTemplate get task template template

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIGetTaskTemplateRequest
*/
func (a *TaskAPIService) DMAPIGetTaskTemplate(ctx context.Context, taskName string) ApiDMAPIGetTaskTemplateRequest {
	return ApiDMAPIGetTaskTemplateRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
//
//	@return Task
func (a *TaskAPIService) DMAPIGetTaskTemplateExecute(r ApiDMAPIGetTaskTemplateRequest) (*Task, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *Task
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTaskTemplate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIGetTaskTemplateListRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
}

func (r ApiDMAPIGetTaskTemplateListRequest) Execute() (*GetTaskListResponse, *http.Response, error) {
	return r.ApiService.DMAPIGetTaskTemplateListExecute(r)
}

/*
DMAPIGetTaskTemplateList get task template list

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPIGetTaskTemplateListRequest
*/
func (a *TaskAPIService) DMAPIGetTaskTemplateList(ctx context.Context) ApiDMAPIGetTaskTemplateListRequest {
	return ApiDMAPIGetTaskTemplateListRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return GetTaskListResponse
func (a *TaskAPIService) DMAPIGetTaskTemplateListExecute(r ApiDMAPIGetTaskTemplateListRequest) (*GetTaskListResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodGet
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *GetTaskListResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIGetTaskTemplateList")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIImportTaskTemplateRequest struct {
	ctx                 context.Context
	ApiService          *TaskAPIService
	taskTemplateRequest *TaskTemplateRequest
}

// request body
func (r ApiDMAPIImportTaskTemplateRequest) TaskTemplateRequest(taskTemplateRequest TaskTemplateRequest) ApiDMAPIImportTaskTemplateRequest {
	r.taskTemplateRequest = &taskTemplateRequest
	return r
}

func (r ApiDMAPIImportTaskTemplateRequest) Execute() (*TaskTemplateResponse, *http.Response, error) {
	return r.ApiService.DMAPIImportTaskTemplateExecute(r)
}

/*
DMAPIImportTaskTemplate import task template

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@return ApiDMAPIImportTaskTemplateRequest
*/
func (a *TaskAPIService) DMAPIImportTaskTemplate(ctx context.Context) ApiDMAPIImportTaskTemplateRequest {
	return ApiDMAPIImportTaskTemplateRequest{
		ApiService: a,
		ctx:        ctx,
	}
}

// Execute executes the request
//
//	@return TaskTemplateResponse
func (a *TaskAPIService) DMAPIImportTaskTemplateExecute(r ApiDMAPIImportTaskTemplateRequest) (*TaskTemplateResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPost
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *TaskTemplateResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIImportTaskTemplate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates/import"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.taskTemplateRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPIOperateTableStructureRequest struct {
	ctx                              context.Context
	ApiService                       *TaskAPIService
	taskName                         string
	sourceName                       string
	schemaName                       string
	tableName                        string
	operateTaskTableStructureRequest *OperateTaskTableStructureRequest
}

func (r ApiDMAPIOperateTableStructureRequest) OperateTaskTableStructureRequest(operateTaskTableStructureRequest OperateTaskTableStructureRequest) ApiDMAPIOperateTableStructureRequest {
	r.operateTaskTableStructureRequest = &operateTaskTableStructureRequest
	return r
}

func (r ApiDMAPIOperateTableStructureRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIOperateTableStructureExecute(r)
}

/*
DMAPIOperateTableStructure operate task source table structure

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@param sourceName source name
	@param schemaName schema name
	@param tableName table name
	@return ApiDMAPIOperateTableStructureRequest
*/
func (a *TaskAPIService) DMAPIOperateTableStructure(ctx context.Context, taskName string, sourceName string, schemaName string, tableName string) ApiDMAPIOperateTableStructureRequest {
	return ApiDMAPIOperateTableStructureRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
		sourceName: sourceName,
		schemaName: schemaName,
		tableName:  tableName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIOperateTableStructureExecute(r ApiDMAPIOperateTableStructureRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPut
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIOperateTableStructure")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/sources/{source-name}/schemas/{schema-name}/{table-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"source-name"+"}", url.PathEscape(parameterValueToString(r.sourceName, "sourceName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"schema-name"+"}", url.PathEscape(parameterValueToString(r.schemaName, "schemaName")), -1)
	localVarPath = strings.Replace(localVarPath, "{"+"table-name"+"}", url.PathEscape(parameterValueToString(r.tableName, "tableName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.operateTaskTableStructureRequest == nil {
		return nil, reportError("operateTaskTableStructureRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.operateTaskTableStructureRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIStartTaskRequest struct {
	ctx              context.Context
	ApiService       *TaskAPIService
	taskName         string
	startTaskRequest *StartTaskRequest
}

func (r ApiDMAPIStartTaskRequest) StartTaskRequest(startTaskRequest StartTaskRequest) ApiDMAPIStartTaskRequest {
	r.startTaskRequest = &startTaskRequest
	return r
}

func (r ApiDMAPIStartTaskRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIStartTaskExecute(r)
}

/*
DMAPIStartTask start a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIStartTaskRequest
*/
func (a *TaskAPIService) DMAPIStartTask(ctx context.Context, taskName string) ApiDMAPIStartTaskRequest {
	return ApiDMAPIStartTaskRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIStartTaskExecute(r ApiDMAPIStartTaskRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIStartTask")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/start"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.startTaskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIStopTaskRequest struct {
	ctx             context.Context
	ApiService      *TaskAPIService
	taskName        string
	stopTaskRequest *StopTaskRequest
}

func (r ApiDMAPIStopTaskRequest) StopTaskRequest(stopTaskRequest StopTaskRequest) ApiDMAPIStopTaskRequest {
	r.stopTaskRequest = &stopTaskRequest
	return r
}

func (r ApiDMAPIStopTaskRequest) Execute() (*http.Response, error) {
	return r.ApiService.DMAPIStopTaskExecute(r)
}

/*
DMAPIStopTask stop a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIStopTaskRequest
*/
func (a *TaskAPIService) DMAPIStopTask(ctx context.Context, taskName string) ApiDMAPIStopTaskRequest {
	return ApiDMAPIStopTaskRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
func (a *TaskAPIService) DMAPIStopTaskExecute(r ApiDMAPIStopTaskRequest) (*http.Response, error) {
	var (
		localVarHTTPMethod = http.MethodPost
		localVarPostBody   interface{}
		formFiles          []formFile
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIStopTask")
	if err != nil {
		return nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}/stop"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.stopTaskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarHTTPResponse, newErr
	}

	return localVarHTTPResponse, nil
}

type ApiDMAPIUpdateTaskRequest struct {
	ctx               context.Context
	ApiService        *TaskAPIService
	taskName          string
	updateTaskRequest *UpdateTaskRequest
}

// request body
func (r ApiDMAPIUpdateTaskRequest) UpdateTaskRequest(updateTaskRequest UpdateTaskRequest) ApiDMAPIUpdateTaskRequest {
	r.updateTaskRequest = &updateTaskRequest
	return r
}

func (r ApiDMAPIUpdateTaskRequest) Execute() (*OperateTaskResponse, *http.Response, error) {
	return r.ApiService.DMAPIUpdateTaskExecute(r)
}

/*
DMAPIUpdateTask update a task

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPIUpdateTaskRequest
*/
func (a *TaskAPIService) DMAPIUpdateTask(ctx context.Context, taskName string) ApiDMAPIUpdateTaskRequest {
	return ApiDMAPIUpdateTaskRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
//
//	@return OperateTaskResponse
func (a *TaskAPIService) DMAPIUpdateTaskExecute(r ApiDMAPIUpdateTaskRequest) (*OperateTaskResponse, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPut
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *OperateTaskResponse
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPIUpdateTask")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.updateTaskRequest
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiDMAPUpdateTaskTemplateRequest struct {
	ctx        context.Context
	ApiService *TaskAPIService
	taskName   string
}

func (r ApiDMAPUpdateTaskTemplateRequest) Execute() (*Task, *http.Response, error) {
	return r.ApiService.DMAPUpdateTaskTemplateExecute(r)
}

/*
DMAPUpdateTaskTemplate update task template template

	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
	@param taskName globally unique task name
	@return ApiDMAPUpdateTaskTemplateRequest
*/
func (a *TaskAPIService) DMAPUpdateTaskTemplate(ctx context.Context, taskName string) ApiDMAPUpdateTaskTemplateRequest {
	return ApiDMAPUpdateTaskTemplateRequest{
		ApiService: a,
		ctx:        ctx,
		taskName:   taskName,
	}
}

// Execute executes the request
//
//	@return Task
func (a *TaskAPIService) DMAPUpdateTaskTemplateExecute(r ApiDMAPUpdateTaskTemplateRequest) (*Task, *http.Response, error) {
	var (
		localVarHTTPMethod  = http.MethodPut
		localVarPostBody    interface{}
		formFiles           []formFile
		localVarReturnValue *Task
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "TaskAPIService.DMAPUpdateTaskTemplate")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/api/v1/tasks/templates/{task-name}"
	localVarPath = strings.Replace(localVarPath, "{"+"task-name"+"}", url.PathEscape(parameterValueToString(r.taskName, "taskName")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		if localVarHTTPResponse.StatusCode == 400 {
			var v ErrorWithMessage
			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
			if err != nil {
				newErr.error = err.Error()
				return localVarReturnValue, localVarHTTPResponse, newErr
			}
			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
			newErr.model = v
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}