// Code generated by go-swagger; DO NOT EDIT.

package operations

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"fmt"

	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
)

// New creates a new operations API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) ClientService {
	return &Client{transport: transport, formats: formats}
}

/*
Client for operations API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	CancelCheck(params *CancelCheckParams, opts ...ClientOption) (*CancelCheckAccepted, *CancelCheckNoContent, error)

	CancelCollectJob(params *CancelCollectJobParams, opts ...ClientOption) (*CancelCollectJobAccepted, error)

	CancelDataUpload(params *CancelDataUploadParams, opts ...ClientOption) (*CancelDataUploadAccepted, *CancelDataUploadNoContent, error)

	CheckDataSet(params *CheckDataSetParams, opts ...ClientOption) (*CheckDataSetOK, error)

	CollectData(params *CollectDataParams, opts ...ClientOption) (*CollectDataAccepted, error)

	DeleteDataSet(params *DeleteDataSetParams, opts ...ClientOption) (*DeleteDataSetNoContent, error)

	GetCheckResult(params *GetCheckResultParams, opts ...ClientOption) (*GetCheckResultOK, *GetCheckResultNoContent, error)

	GetCollectJob(params *GetCollectJobParams, opts ...ClientOption) (*GetCollectJobOK, error)

	GetCollectJobLogs(params *GetCollectJobLogsParams, opts ...ClientOption) (*GetCollectJobLogsOK, error)

	GetDataList(params *GetDataListParams, opts ...ClientOption) (*GetDataListOK, error)

	GetDataSet(params *GetDataSetParams, opts ...ClientOption) (*GetDataSetOK, error)

	GetJobList(params *GetJobListParams, opts ...ClientOption) (*GetJobListOK, error)

	GetStatus(params *GetStatusParams, opts ...ClientOption) (*GetStatusOK, error)

	GetUploadTask(params *GetUploadTaskParams, opts ...ClientOption) (*GetUploadTaskOK, *GetUploadTaskNoContent, error)

	GetVersion(params *GetVersionParams, opts ...ClientOption) (*GetVersionOK, error)

	UploadDataSet(params *UploadDataSetParams, opts ...ClientOption) (*UploadDataSetAccepted, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  CancelCheck cancel check API
*/
func (a *Client) CancelCheck(params *CancelCheckParams, opts ...ClientOption) (*CancelCheckAccepted, *CancelCheckNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCancelCheckParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "cancelCheck",
		Method:             "DELETE",
		PathPattern:        "/data/{id}/check",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CancelCheckReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *CancelCheckAccepted:
		return value, nil, nil
	case *CancelCheckNoContent:
		return nil, value, nil
	}
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for operations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  CancelCollectJob cancel collect job API
*/
func (a *Client) CancelCollectJob(params *CancelCollectJobParams, opts ...ClientOption) (*CancelCollectJobAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCancelCollectJobParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "cancelCollectJob",
		Method:             "DELETE",
		PathPattern:        "/collectors/{id}",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CancelCollectJobReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CancelCollectJobAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for cancelCollectJob: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  CancelDataUpload cancel data upload API
*/
func (a *Client) CancelDataUpload(params *CancelDataUploadParams, opts ...ClientOption) (*CancelDataUploadAccepted, *CancelDataUploadNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCancelDataUploadParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "cancelDataUpload",
		Method:             "DELETE",
		PathPattern:        "/data/{id}/upload",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CancelDataUploadReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *CancelDataUploadAccepted:
		return value, nil, nil
	case *CancelDataUploadNoContent:
		return nil, value, nil
	}
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for operations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  CheckDataSet check data set API
*/
func (a *Client) CheckDataSet(params *CheckDataSetParams, opts ...ClientOption) (*CheckDataSetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCheckDataSetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "checkDataSet",
		Method:             "POST",
		PathPattern:        "/data/{id}/check",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CheckDataSetReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CheckDataSetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for checkDataSet: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  CollectData collect data API
*/
func (a *Client) CollectData(params *CollectDataParams, opts ...ClientOption) (*CollectDataAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCollectDataParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "collectData",
		Method:             "POST",
		PathPattern:        "/collectors",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &CollectDataReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*CollectDataAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for collectData: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteDataSet delete data set API
*/
func (a *Client) DeleteDataSet(params *DeleteDataSetParams, opts ...ClientOption) (*DeleteDataSetNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDataSetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteDataSet",
		Method:             "DELETE",
		PathPattern:        "/data/{id}",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &DeleteDataSetReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteDataSetNoContent)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteDataSet: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCheckResult get check result API
*/
func (a *Client) GetCheckResult(params *GetCheckResultParams, opts ...ClientOption) (*GetCheckResultOK, *GetCheckResultNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCheckResultParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCheckResult",
		Method:             "GET",
		PathPattern:        "/data/{id}/check",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCheckResultReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetCheckResultOK:
		return value, nil, nil
	case *GetCheckResultNoContent:
		return nil, value, nil
	}
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for operations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCollectJob get collect job API
*/
func (a *Client) GetCollectJob(params *GetCollectJobParams, opts ...ClientOption) (*GetCollectJobOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectJobParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCollectJob",
		Method:             "GET",
		PathPattern:        "/collectors/{id}",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCollectJobReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCollectJobOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getCollectJob: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetCollectJobLogs get collect job logs API
*/
func (a *Client) GetCollectJobLogs(params *GetCollectJobLogsParams, opts ...ClientOption) (*GetCollectJobLogsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectJobLogsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getCollectJobLogs",
		Method:             "GET",
		PathPattern:        "/collectors/{id}/logs",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetCollectJobLogsReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetCollectJobLogsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getCollectJobLogs: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetDataList get data list API
*/
func (a *Client) GetDataList(params *GetDataListParams, opts ...ClientOption) (*GetDataListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDataListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDataList",
		Method:             "GET",
		PathPattern:        "/data",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetDataListReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDataListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDataList: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetDataSet get data set API
*/
func (a *Client) GetDataSet(params *GetDataSetParams, opts ...ClientOption) (*GetDataSetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDataSetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getDataSet",
		Method:             "GET",
		PathPattern:        "/data/{id}",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetDataSetReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetDataSetOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getDataSet: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetJobList get job list API
*/
func (a *Client) GetJobList(params *GetJobListParams, opts ...ClientOption) (*GetJobListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetJobListParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getJobList",
		Method:             "GET",
		PathPattern:        "/collectors",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetJobListReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetJobListOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getJobList: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetStatus get status API
*/
func (a *Client) GetStatus(params *GetStatusParams, opts ...ClientOption) (*GetStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetStatusParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getStatus",
		Method:             "GET",
		PathPattern:        "/status",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetStatusReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetStatusOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getStatus: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetUploadTask get upload task API
*/
func (a *Client) GetUploadTask(params *GetUploadTaskParams, opts ...ClientOption) (*GetUploadTaskOK, *GetUploadTaskNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUploadTaskParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getUploadTask",
		Method:             "GET",
		PathPattern:        "/data/{id}/upload",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetUploadTaskReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, nil, err
	}
	switch value := result.(type) {
	case *GetUploadTaskOK:
		return value, nil, nil
	case *GetUploadTaskNoContent:
		return nil, value, nil
	}
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for operations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetVersion get version API
*/
func (a *Client) GetVersion(params *GetVersionParams, opts ...ClientOption) (*GetVersionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVersionParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getVersion",
		Method:             "GET",
		PathPattern:        "/version",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &GetVersionReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetVersionOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getVersion: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  UploadDataSet upload data set API
*/
func (a *Client) UploadDataSet(params *UploadDataSetParams, opts ...ClientOption) (*UploadDataSetAccepted, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUploadDataSetParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "uploadDataSet",
		Method:             "POST",
		PathPattern:        "/data/{id}/upload",
		ProducesMediaTypes: []string{"application/json", "text/plain"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &UploadDataSetReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*UploadDataSetAccepted)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for uploadDataSet: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}