viapi_regen

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 25, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source 
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap 

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType 

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty 

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient 

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type Boxes 

type Boxes struct {
	X      float64 `json:"X" xml:"X"`
	Height float64 `json:"Height" xml:"Height"`
	Width  float64 `json:"Width" xml:"Width"`
	Y      float64 `json:"Y" xml:"Y"`
}

Boxes is a nested struct in viapi_regen response

type BoxesInCustomizeInstanceSegmentImage 

type BoxesInCustomizeInstanceSegmentImage struct {
	X      int `json:"X" xml:"X"`
	Y      int `json:"Y" xml:"Y"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
}

BoxesInCustomizeInstanceSegmentImage is a nested struct in viapi_regen response

type CheckDatasetOssBucketCORSRequest 

type CheckDatasetOssBucketCORSRequest struct {
	*requests.RpcRequest
	LabelsetId requests.Integer `position:"Body" name:"LabelsetId"`
}

CheckDatasetOssBucketCORSRequest is the request struct for api CheckDatasetOssBucketCORS

func CreateCheckDatasetOssBucketCORSRequest 

func CreateCheckDatasetOssBucketCORSRequest() (request *CheckDatasetOssBucketCORSRequest)

CreateCheckDatasetOssBucketCORSRequest creates a request to invoke CheckDatasetOssBucketCORS API

type CheckDatasetOssBucketCORSResponse 

type CheckDatasetOssBucketCORSResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CheckDatasetOssBucketCORSResponse is the response struct for api CheckDatasetOssBucketCORS

func CreateCheckDatasetOssBucketCORSResponse 

func CreateCheckDatasetOssBucketCORSResponse() (response *CheckDatasetOssBucketCORSResponse)

CreateCheckDatasetOssBucketCORSResponse creates a response to parse from CheckDatasetOssBucketCORS response

type Client 

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient 

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey 

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole 

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions 

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider 

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn 

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy 

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair 

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken 

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) CheckDatasetOssBucketCORS 

func (client *Client) CheckDatasetOssBucketCORS(request *CheckDatasetOssBucketCORSRequest) (response *CheckDatasetOssBucketCORSResponse, err error)

CheckDatasetOssBucketCORS invokes the viapi_regen.CheckDatasetOssBucketCORS API synchronously

func (*Client) CheckDatasetOssBucketCORSWithCallback 

func (client *Client) CheckDatasetOssBucketCORSWithCallback(request *CheckDatasetOssBucketCORSRequest, callback func(response *CheckDatasetOssBucketCORSResponse, err error)) <-chan int

CheckDatasetOssBucketCORSWithCallback invokes the viapi_regen.CheckDatasetOssBucketCORS API asynchronously

func (*Client) CheckDatasetOssBucketCORSWithChan 

func (client *Client) CheckDatasetOssBucketCORSWithChan(request *CheckDatasetOssBucketCORSRequest) (<-chan *CheckDatasetOssBucketCORSResponse, <-chan error)

CheckDatasetOssBucketCORSWithChan invokes the viapi_regen.CheckDatasetOssBucketCORS API asynchronously

func (*Client) CreateDataset 

func (client *Client) CreateDataset(request *CreateDatasetRequest) (response *CreateDatasetResponse, err error)

CreateDataset invokes the viapi_regen.CreateDataset API synchronously

func (*Client) CreateDatasetWithCallback 

func (client *Client) CreateDatasetWithCallback(request *CreateDatasetRequest, callback func(response *CreateDatasetResponse, err error)) <-chan int

CreateDatasetWithCallback invokes the viapi_regen.CreateDataset API asynchronously

func (*Client) CreateDatasetWithChan 

func (client *Client) CreateDatasetWithChan(request *CreateDatasetRequest) (<-chan *CreateDatasetResponse, <-chan error)

CreateDatasetWithChan invokes the viapi_regen.CreateDataset API asynchronously

func (*Client) CreateLabelset 

func (client *Client) CreateLabelset(request *CreateLabelsetRequest) (response *CreateLabelsetResponse, err error)

CreateLabelset invokes the viapi_regen.CreateLabelset API synchronously

func (*Client) CreateLabelsetWithCallback 

func (client *Client) CreateLabelsetWithCallback(request *CreateLabelsetRequest, callback func(response *CreateLabelsetResponse, err error)) <-chan int

CreateLabelsetWithCallback invokes the viapi_regen.CreateLabelset API asynchronously

func (*Client) CreateLabelsetWithChan 

func (client *Client) CreateLabelsetWithChan(request *CreateLabelsetRequest) (<-chan *CreateLabelsetResponse, <-chan error)

CreateLabelsetWithChan invokes the viapi_regen.CreateLabelset API asynchronously

func (*Client) CreateService 

func (client *Client) CreateService(request *CreateServiceRequest) (response *CreateServiceResponse, err error)

CreateService invokes the viapi_regen.CreateService API synchronously

func (*Client) CreateServiceWithCallback 

func (client *Client) CreateServiceWithCallback(request *CreateServiceRequest, callback func(response *CreateServiceResponse, err error)) <-chan int

CreateServiceWithCallback invokes the viapi_regen.CreateService API asynchronously

func (*Client) CreateServiceWithChan 

func (client *Client) CreateServiceWithChan(request *CreateServiceRequest) (<-chan *CreateServiceResponse, <-chan error)

CreateServiceWithChan invokes the viapi_regen.CreateService API asynchronously

func (*Client) CreateTagTask 

func (client *Client) CreateTagTask(request *CreateTagTaskRequest) (response *CreateTagTaskResponse, err error)

CreateTagTask invokes the viapi_regen.CreateTagTask API synchronously

func (*Client) CreateTagTaskWithCallback 

func (client *Client) CreateTagTaskWithCallback(request *CreateTagTaskRequest, callback func(response *CreateTagTaskResponse, err error)) <-chan int

CreateTagTaskWithCallback invokes the viapi_regen.CreateTagTask API asynchronously

func (*Client) CreateTagTaskWithChan 

func (client *Client) CreateTagTaskWithChan(request *CreateTagTaskRequest) (<-chan *CreateTagTaskResponse, <-chan error)

CreateTagTaskWithChan invokes the viapi_regen.CreateTagTask API asynchronously

func (*Client) CreateTrainTask 

func (client *Client) CreateTrainTask(request *CreateTrainTaskRequest) (response *CreateTrainTaskResponse, err error)

CreateTrainTask invokes the viapi_regen.CreateTrainTask API synchronously

func (*Client) CreateTrainTaskWithCallback 

func (client *Client) CreateTrainTaskWithCallback(request *CreateTrainTaskRequest, callback func(response *CreateTrainTaskResponse, err error)) <-chan int

CreateTrainTaskWithCallback invokes the viapi_regen.CreateTrainTask API asynchronously

func (*Client) CreateTrainTaskWithChan 

func (client *Client) CreateTrainTaskWithChan(request *CreateTrainTaskRequest) (<-chan *CreateTrainTaskResponse, <-chan error)

CreateTrainTaskWithChan invokes the viapi_regen.CreateTrainTask API asynchronously

func (*Client) CreateWorkspace 

func (client *Client) CreateWorkspace(request *CreateWorkspaceRequest) (response *CreateWorkspaceResponse, err error)

CreateWorkspace invokes the viapi_regen.CreateWorkspace API synchronously

func (*Client) CreateWorkspaceWithCallback 

func (client *Client) CreateWorkspaceWithCallback(request *CreateWorkspaceRequest, callback func(response *CreateWorkspaceResponse, err error)) <-chan int

CreateWorkspaceWithCallback invokes the viapi_regen.CreateWorkspace API asynchronously

func (*Client) CreateWorkspaceWithChan 

func (client *Client) CreateWorkspaceWithChan(request *CreateWorkspaceRequest) (<-chan *CreateWorkspaceResponse, <-chan error)

CreateWorkspaceWithChan invokes the viapi_regen.CreateWorkspace API asynchronously

func (*Client) CustomizeClassifyImage 

func (client *Client) CustomizeClassifyImage(request *CustomizeClassifyImageRequest) (response *CustomizeClassifyImageResponse, err error)

CustomizeClassifyImage invokes the viapi_regen.CustomizeClassifyImage API synchronously

func (*Client) CustomizeClassifyImageWithCallback 

func (client *Client) CustomizeClassifyImageWithCallback(request *CustomizeClassifyImageRequest, callback func(response *CustomizeClassifyImageResponse, err error)) <-chan int

CustomizeClassifyImageWithCallback invokes the viapi_regen.CustomizeClassifyImage API asynchronously

func (*Client) CustomizeClassifyImageWithChan 

func (client *Client) CustomizeClassifyImageWithChan(request *CustomizeClassifyImageRequest) (<-chan *CustomizeClassifyImageResponse, <-chan error)

CustomizeClassifyImageWithChan invokes the viapi_regen.CustomizeClassifyImage API asynchronously

func (*Client) CustomizeDetectImage 

func (client *Client) CustomizeDetectImage(request *CustomizeDetectImageRequest) (response *CustomizeDetectImageResponse, err error)

CustomizeDetectImage invokes the viapi_regen.CustomizeDetectImage API synchronously

func (*Client) CustomizeDetectImageWithCallback 

func (client *Client) CustomizeDetectImageWithCallback(request *CustomizeDetectImageRequest, callback func(response *CustomizeDetectImageResponse, err error)) <-chan int

CustomizeDetectImageWithCallback invokes the viapi_regen.CustomizeDetectImage API asynchronously

func (*Client) CustomizeDetectImageWithChan 

func (client *Client) CustomizeDetectImageWithChan(request *CustomizeDetectImageRequest) (<-chan *CustomizeDetectImageResponse, <-chan error)

CustomizeDetectImageWithChan invokes the viapi_regen.CustomizeDetectImage API asynchronously

func (*Client) CustomizeInstanceSegmentImage 

func (client *Client) CustomizeInstanceSegmentImage(request *CustomizeInstanceSegmentImageRequest) (response *CustomizeInstanceSegmentImageResponse, err error)

CustomizeInstanceSegmentImage invokes the viapi_regen.CustomizeInstanceSegmentImage API synchronously

func (*Client) CustomizeInstanceSegmentImageWithCallback 

func (client *Client) CustomizeInstanceSegmentImageWithCallback(request *CustomizeInstanceSegmentImageRequest, callback func(response *CustomizeInstanceSegmentImageResponse, err error)) <-chan int

CustomizeInstanceSegmentImageWithCallback invokes the viapi_regen.CustomizeInstanceSegmentImage API asynchronously

func (*Client) CustomizeInstanceSegmentImageWithChan 

func (client *Client) CustomizeInstanceSegmentImageWithChan(request *CustomizeInstanceSegmentImageRequest) (<-chan *CustomizeInstanceSegmentImageResponse, <-chan error)

CustomizeInstanceSegmentImageWithChan invokes the viapi_regen.CustomizeInstanceSegmentImage API asynchronously

func (*Client) DebugService 

func (client *Client) DebugService(request *DebugServiceRequest) (response *DebugServiceResponse, err error)

DebugService invokes the viapi_regen.DebugService API synchronously

func (*Client) DebugServiceWithCallback 

func (client *Client) DebugServiceWithCallback(request *DebugServiceRequest, callback func(response *DebugServiceResponse, err error)) <-chan int

DebugServiceWithCallback invokes the viapi_regen.DebugService API asynchronously

func (*Client) DebugServiceWithChan 

func (client *Client) DebugServiceWithChan(request *DebugServiceRequest) (<-chan *DebugServiceResponse, <-chan error)

DebugServiceWithChan invokes the viapi_regen.DebugService API asynchronously

func (*Client) DeleteDataReflowData 

func (client *Client) DeleteDataReflowData(request *DeleteDataReflowDataRequest) (response *DeleteDataReflowDataResponse, err error)

DeleteDataReflowData invokes the viapi_regen.DeleteDataReflowData API synchronously

func (*Client) DeleteDataReflowDataWithCallback 

func (client *Client) DeleteDataReflowDataWithCallback(request *DeleteDataReflowDataRequest, callback func(response *DeleteDataReflowDataResponse, err error)) <-chan int

DeleteDataReflowDataWithCallback invokes the viapi_regen.DeleteDataReflowData API asynchronously

func (*Client) DeleteDataReflowDataWithChan 

func (client *Client) DeleteDataReflowDataWithChan(request *DeleteDataReflowDataRequest) (<-chan *DeleteDataReflowDataResponse, <-chan error)

DeleteDataReflowDataWithChan invokes the viapi_regen.DeleteDataReflowData API asynchronously

func (*Client) DeleteDataset 

func (client *Client) DeleteDataset(request *DeleteDatasetRequest) (response *DeleteDatasetResponse, err error)

DeleteDataset invokes the viapi_regen.DeleteDataset API synchronously

func (*Client) DeleteDatasetWithCallback 

func (client *Client) DeleteDatasetWithCallback(request *DeleteDatasetRequest, callback func(response *DeleteDatasetResponse, err error)) <-chan int

DeleteDatasetWithCallback invokes the viapi_regen.DeleteDataset API asynchronously

func (*Client) DeleteDatasetWithChan 

func (client *Client) DeleteDatasetWithChan(request *DeleteDatasetRequest) (<-chan *DeleteDatasetResponse, <-chan error)

DeleteDatasetWithChan invokes the viapi_regen.DeleteDataset API asynchronously

func (*Client) DeleteLabelset 

func (client *Client) DeleteLabelset(request *DeleteLabelsetRequest) (response *DeleteLabelsetResponse, err error)

DeleteLabelset invokes the viapi_regen.DeleteLabelset API synchronously

func (*Client) DeleteLabelsetData 

func (client *Client) DeleteLabelsetData(request *DeleteLabelsetDataRequest) (response *DeleteLabelsetDataResponse, err error)

DeleteLabelsetData invokes the viapi_regen.DeleteLabelsetData API synchronously

func (*Client) DeleteLabelsetDataWithCallback 

func (client *Client) DeleteLabelsetDataWithCallback(request *DeleteLabelsetDataRequest, callback func(response *DeleteLabelsetDataResponse, err error)) <-chan int

DeleteLabelsetDataWithCallback invokes the viapi_regen.DeleteLabelsetData API asynchronously

func (*Client) DeleteLabelsetDataWithChan 

func (client *Client) DeleteLabelsetDataWithChan(request *DeleteLabelsetDataRequest) (<-chan *DeleteLabelsetDataResponse, <-chan error)

DeleteLabelsetDataWithChan invokes the viapi_regen.DeleteLabelsetData API asynchronously

func (*Client) DeleteLabelsetWithCallback 

func (client *Client) DeleteLabelsetWithCallback(request *DeleteLabelsetRequest, callback func(response *DeleteLabelsetResponse, err error)) <-chan int

DeleteLabelsetWithCallback invokes the viapi_regen.DeleteLabelset API asynchronously

func (*Client) DeleteLabelsetWithChan 

func (client *Client) DeleteLabelsetWithChan(request *DeleteLabelsetRequest) (<-chan *DeleteLabelsetResponse, <-chan error)

DeleteLabelsetWithChan invokes the viapi_regen.DeleteLabelset API asynchronously

func (*Client) DeleteService 

func (client *Client) DeleteService(request *DeleteServiceRequest) (response *DeleteServiceResponse, err error)

DeleteService invokes the viapi_regen.DeleteService API synchronously

func (*Client) DeleteServiceWithCallback 

func (client *Client) DeleteServiceWithCallback(request *DeleteServiceRequest, callback func(response *DeleteServiceResponse, err error)) <-chan int

DeleteServiceWithCallback invokes the viapi_regen.DeleteService API asynchronously

func (*Client) DeleteServiceWithChan 

func (client *Client) DeleteServiceWithChan(request *DeleteServiceRequest) (<-chan *DeleteServiceResponse, <-chan error)

DeleteServiceWithChan invokes the viapi_regen.DeleteService API asynchronously

func (*Client) DeleteTrainTask 

func (client *Client) DeleteTrainTask(request *DeleteTrainTaskRequest) (response *DeleteTrainTaskResponse, err error)

DeleteTrainTask invokes the viapi_regen.DeleteTrainTask API synchronously

func (*Client) DeleteTrainTaskWithCallback 

func (client *Client) DeleteTrainTaskWithCallback(request *DeleteTrainTaskRequest, callback func(response *DeleteTrainTaskResponse, err error)) <-chan int

DeleteTrainTaskWithCallback invokes the viapi_regen.DeleteTrainTask API asynchronously

func (*Client) DeleteTrainTaskWithChan 

func (client *Client) DeleteTrainTaskWithChan(request *DeleteTrainTaskRequest) (<-chan *DeleteTrainTaskResponse, <-chan error)

DeleteTrainTaskWithChan invokes the viapi_regen.DeleteTrainTask API asynchronously

func (*Client) DeleteWorkspace 

func (client *Client) DeleteWorkspace(request *DeleteWorkspaceRequest) (response *DeleteWorkspaceResponse, err error)

DeleteWorkspace invokes the viapi_regen.DeleteWorkspace API synchronously

func (*Client) DeleteWorkspaceWithCallback 

func (client *Client) DeleteWorkspaceWithCallback(request *DeleteWorkspaceRequest, callback func(response *DeleteWorkspaceResponse, err error)) <-chan int

DeleteWorkspaceWithCallback invokes the viapi_regen.DeleteWorkspace API asynchronously

func (*Client) DeleteWorkspaceWithChan 

func (client *Client) DeleteWorkspaceWithChan(request *DeleteWorkspaceRequest) (<-chan *DeleteWorkspaceResponse, <-chan error)

DeleteWorkspaceWithChan invokes the viapi_regen.DeleteWorkspace API asynchronously

func (*Client) DisableDataReflow 

func (client *Client) DisableDataReflow(request *DisableDataReflowRequest) (response *DisableDataReflowResponse, err error)

DisableDataReflow invokes the viapi_regen.DisableDataReflow API synchronously

func (*Client) DisableDataReflowWithCallback 

func (client *Client) DisableDataReflowWithCallback(request *DisableDataReflowRequest, callback func(response *DisableDataReflowResponse, err error)) <-chan int

DisableDataReflowWithCallback invokes the viapi_regen.DisableDataReflow API asynchronously

func (*Client) DisableDataReflowWithChan 

func (client *Client) DisableDataReflowWithChan(request *DisableDataReflowRequest) (<-chan *DisableDataReflowResponse, <-chan error)

DisableDataReflowWithChan invokes the viapi_regen.DisableDataReflow API asynchronously

func (*Client) DownloadDataset 

func (client *Client) DownloadDataset(request *DownloadDatasetRequest) (response *DownloadDatasetResponse, err error)

DownloadDataset invokes the viapi_regen.DownloadDataset API synchronously

func (*Client) DownloadDatasetWithCallback 

func (client *Client) DownloadDatasetWithCallback(request *DownloadDatasetRequest, callback func(response *DownloadDatasetResponse, err error)) <-chan int

DownloadDatasetWithCallback invokes the viapi_regen.DownloadDataset API asynchronously

func (*Client) DownloadDatasetWithChan 

func (client *Client) DownloadDatasetWithChan(request *DownloadDatasetRequest) (<-chan *DownloadDatasetResponse, <-chan error)

DownloadDatasetWithChan invokes the viapi_regen.DownloadDataset API asynchronously

func (*Client) DownloadFileNameList 

func (client *Client) DownloadFileNameList(request *DownloadFileNameListRequest) (response *DownloadFileNameListResponse, err error)

DownloadFileNameList invokes the viapi_regen.DownloadFileNameList API synchronously

func (*Client) DownloadFileNameListWithCallback 

func (client *Client) DownloadFileNameListWithCallback(request *DownloadFileNameListRequest, callback func(response *DownloadFileNameListResponse, err error)) <-chan int

DownloadFileNameListWithCallback invokes the viapi_regen.DownloadFileNameList API asynchronously

func (*Client) DownloadFileNameListWithChan 

func (client *Client) DownloadFileNameListWithChan(request *DownloadFileNameListRequest) (<-chan *DownloadFileNameListResponse, <-chan error)

DownloadFileNameListWithChan invokes the viapi_regen.DownloadFileNameList API asynchronously

func (*Client) DownloadLabelFile 

func (client *Client) DownloadLabelFile(request *DownloadLabelFileRequest) (response *DownloadLabelFileResponse, err error)

DownloadLabelFile invokes the viapi_regen.DownloadLabelFile API synchronously

func (*Client) DownloadLabelFileWithCallback 

func (client *Client) DownloadLabelFileWithCallback(request *DownloadLabelFileRequest, callback func(response *DownloadLabelFileResponse, err error)) <-chan int

DownloadLabelFileWithCallback invokes the viapi_regen.DownloadLabelFile API asynchronously

func (*Client) DownloadLabelFileWithChan 

func (client *Client) DownloadLabelFileWithChan(request *DownloadLabelFileRequest) (<-chan *DownloadLabelFileResponse, <-chan error)

DownloadLabelFileWithChan invokes the viapi_regen.DownloadLabelFile API asynchronously

func (*Client) EnableDataReflow 

func (client *Client) EnableDataReflow(request *EnableDataReflowRequest) (response *EnableDataReflowResponse, err error)

EnableDataReflow invokes the viapi_regen.EnableDataReflow API synchronously

func (*Client) EnableDataReflowWithCallback 

func (client *Client) EnableDataReflowWithCallback(request *EnableDataReflowRequest, callback func(response *EnableDataReflowResponse, err error)) <-chan int

EnableDataReflowWithCallback invokes the viapi_regen.EnableDataReflow API asynchronously

func (*Client) EnableDataReflowWithChan 

func (client *Client) EnableDataReflowWithChan(request *EnableDataReflowRequest) (<-chan *EnableDataReflowResponse, <-chan error)

EnableDataReflowWithChan invokes the viapi_regen.EnableDataReflow API asynchronously

func (*Client) ExportDataReflowDataList 

func (client *Client) ExportDataReflowDataList(request *ExportDataReflowDataListRequest) (response *ExportDataReflowDataListResponse, err error)

ExportDataReflowDataList invokes the viapi_regen.ExportDataReflowDataList API synchronously

func (*Client) ExportDataReflowDataListWithCallback 

func (client *Client) ExportDataReflowDataListWithCallback(request *ExportDataReflowDataListRequest, callback func(response *ExportDataReflowDataListResponse, err error)) <-chan int

ExportDataReflowDataListWithCallback invokes the viapi_regen.ExportDataReflowDataList API asynchronously

func (*Client) ExportDataReflowDataListWithChan 

func (client *Client) ExportDataReflowDataListWithChan(request *ExportDataReflowDataListRequest) (<-chan *ExportDataReflowDataListResponse, <-chan error)

ExportDataReflowDataListWithChan invokes the viapi_regen.ExportDataReflowDataList API asynchronously

func (*Client) GetDataset 

func (client *Client) GetDataset(request *GetDatasetRequest) (response *GetDatasetResponse, err error)

GetDataset invokes the viapi_regen.GetDataset API synchronously

func (*Client) GetDatasetWithCallback 

func (client *Client) GetDatasetWithCallback(request *GetDatasetRequest, callback func(response *GetDatasetResponse, err error)) <-chan int

GetDatasetWithCallback invokes the viapi_regen.GetDataset API asynchronously

func (*Client) GetDatasetWithChan 

func (client *Client) GetDatasetWithChan(request *GetDatasetRequest) (<-chan *GetDatasetResponse, <-chan error)

GetDatasetWithChan invokes the viapi_regen.GetDataset API asynchronously

func (*Client) GetDiffCountLabelsetAndDataset 

func (client *Client) GetDiffCountLabelsetAndDataset(request *GetDiffCountLabelsetAndDatasetRequest) (response *GetDiffCountLabelsetAndDatasetResponse, err error)

GetDiffCountLabelsetAndDataset invokes the viapi_regen.GetDiffCountLabelsetAndDataset API synchronously

func (*Client) GetDiffCountLabelsetAndDatasetWithCallback 

func (client *Client) GetDiffCountLabelsetAndDatasetWithCallback(request *GetDiffCountLabelsetAndDatasetRequest, callback func(response *GetDiffCountLabelsetAndDatasetResponse, err error)) <-chan int

GetDiffCountLabelsetAndDatasetWithCallback invokes the viapi_regen.GetDiffCountLabelsetAndDataset API asynchronously

func (*Client) GetDiffCountLabelsetAndDatasetWithChan 

func (client *Client) GetDiffCountLabelsetAndDatasetWithChan(request *GetDiffCountLabelsetAndDatasetRequest) (<-chan *GetDiffCountLabelsetAndDatasetResponse, <-chan error)

GetDiffCountLabelsetAndDatasetWithChan invokes the viapi_regen.GetDiffCountLabelsetAndDataset API asynchronously

func (*Client) GetLabelDetail 

func (client *Client) GetLabelDetail(request *GetLabelDetailRequest) (response *GetLabelDetailResponse, err error)

GetLabelDetail invokes the viapi_regen.GetLabelDetail API synchronously

func (*Client) GetLabelDetailWithCallback 

func (client *Client) GetLabelDetailWithCallback(request *GetLabelDetailRequest, callback func(response *GetLabelDetailResponse, err error)) <-chan int

GetLabelDetailWithCallback invokes the viapi_regen.GetLabelDetail API asynchronously

func (*Client) GetLabelDetailWithChan 

func (client *Client) GetLabelDetailWithChan(request *GetLabelDetailRequest) (<-chan *GetLabelDetailResponse, <-chan error)

GetLabelDetailWithChan invokes the viapi_regen.GetLabelDetail API asynchronously

func (*Client) GetLabelset 

func (client *Client) GetLabelset(request *GetLabelsetRequest) (response *GetLabelsetResponse, err error)

GetLabelset invokes the viapi_regen.GetLabelset API synchronously

func (*Client) GetLabelsetWithCallback 

func (client *Client) GetLabelsetWithCallback(request *GetLabelsetRequest, callback func(response *GetLabelsetResponse, err error)) <-chan int

GetLabelsetWithCallback invokes the viapi_regen.GetLabelset API asynchronously

func (*Client) GetLabelsetWithChan 

func (client *Client) GetLabelsetWithChan(request *GetLabelsetRequest) (<-chan *GetLabelsetResponse, <-chan error)

GetLabelsetWithChan invokes the viapi_regen.GetLabelset API asynchronously

func (*Client) GetService 

func (client *Client) GetService(request *GetServiceRequest) (response *GetServiceResponse, err error)

GetService invokes the viapi_regen.GetService API synchronously

func (*Client) GetServiceInvoke 

func (client *Client) GetServiceInvoke(request *GetServiceInvokeRequest) (response *GetServiceInvokeResponse, err error)

GetServiceInvoke invokes the viapi_regen.GetServiceInvoke API synchronously

func (*Client) GetServiceInvokeWithCallback 

func (client *Client) GetServiceInvokeWithCallback(request *GetServiceInvokeRequest, callback func(response *GetServiceInvokeResponse, err error)) <-chan int

GetServiceInvokeWithCallback invokes the viapi_regen.GetServiceInvoke API asynchronously

func (*Client) GetServiceInvokeWithChan 

func (client *Client) GetServiceInvokeWithChan(request *GetServiceInvokeRequest) (<-chan *GetServiceInvokeResponse, <-chan error)

GetServiceInvokeWithChan invokes the viapi_regen.GetServiceInvoke API asynchronously

func (*Client) GetServiceQps 

func (client *Client) GetServiceQps(request *GetServiceQpsRequest) (response *GetServiceQpsResponse, err error)

GetServiceQps invokes the viapi_regen.GetServiceQps API synchronously

func (*Client) GetServiceQpsWithCallback 

func (client *Client) GetServiceQpsWithCallback(request *GetServiceQpsRequest, callback func(response *GetServiceQpsResponse, err error)) <-chan int

GetServiceQpsWithCallback invokes the viapi_regen.GetServiceQps API asynchronously

func (*Client) GetServiceQpsWithChan 

func (client *Client) GetServiceQpsWithChan(request *GetServiceQpsRequest) (<-chan *GetServiceQpsResponse, <-chan error)

GetServiceQpsWithChan invokes the viapi_regen.GetServiceQps API asynchronously

func (*Client) GetServiceWithCallback 

func (client *Client) GetServiceWithCallback(request *GetServiceRequest, callback func(response *GetServiceResponse, err error)) <-chan int

GetServiceWithCallback invokes the viapi_regen.GetService API asynchronously

func (*Client) GetServiceWithChan 

func (client *Client) GetServiceWithChan(request *GetServiceRequest) (<-chan *GetServiceResponse, <-chan error)

GetServiceWithChan invokes the viapi_regen.GetService API asynchronously

func (*Client) GetTrainModel 

func (client *Client) GetTrainModel(request *GetTrainModelRequest) (response *GetTrainModelResponse, err error)

GetTrainModel invokes the viapi_regen.GetTrainModel API synchronously

func (*Client) GetTrainModelWithCallback 

func (client *Client) GetTrainModelWithCallback(request *GetTrainModelRequest, callback func(response *GetTrainModelResponse, err error)) <-chan int

GetTrainModelWithCallback invokes the viapi_regen.GetTrainModel API asynchronously

func (*Client) GetTrainModelWithChan 

func (client *Client) GetTrainModelWithChan(request *GetTrainModelRequest) (<-chan *GetTrainModelResponse, <-chan error)

GetTrainModelWithChan invokes the viapi_regen.GetTrainModel API asynchronously

func (*Client) GetTrainTask 

func (client *Client) GetTrainTask(request *GetTrainTaskRequest) (response *GetTrainTaskResponse, err error)

GetTrainTask invokes the viapi_regen.GetTrainTask API synchronously

func (*Client) GetTrainTaskEstimatedTime 

func (client *Client) GetTrainTaskEstimatedTime(request *GetTrainTaskEstimatedTimeRequest) (response *GetTrainTaskEstimatedTimeResponse, err error)

GetTrainTaskEstimatedTime invokes the viapi_regen.GetTrainTaskEstimatedTime API synchronously

func (*Client) GetTrainTaskEstimatedTimeWithCallback 

func (client *Client) GetTrainTaskEstimatedTimeWithCallback(request *GetTrainTaskEstimatedTimeRequest, callback func(response *GetTrainTaskEstimatedTimeResponse, err error)) <-chan int

GetTrainTaskEstimatedTimeWithCallback invokes the viapi_regen.GetTrainTaskEstimatedTime API asynchronously

func (*Client) GetTrainTaskEstimatedTimeWithChan 

func (client *Client) GetTrainTaskEstimatedTimeWithChan(request *GetTrainTaskEstimatedTimeRequest) (<-chan *GetTrainTaskEstimatedTimeResponse, <-chan error)

GetTrainTaskEstimatedTimeWithChan invokes the viapi_regen.GetTrainTaskEstimatedTime API asynchronously

func (*Client) GetTrainTaskWithCallback 

func (client *Client) GetTrainTaskWithCallback(request *GetTrainTaskRequest, callback func(response *GetTrainTaskResponse, err error)) <-chan int

GetTrainTaskWithCallback invokes the viapi_regen.GetTrainTask API asynchronously

func (*Client) GetTrainTaskWithChan 

func (client *Client) GetTrainTaskWithChan(request *GetTrainTaskRequest) (<-chan *GetTrainTaskResponse, <-chan error)

GetTrainTaskWithChan invokes the viapi_regen.GetTrainTask API asynchronously

func (*Client) GetUploadPolicy 

func (client *Client) GetUploadPolicy(request *GetUploadPolicyRequest) (response *GetUploadPolicyResponse, err error)

GetUploadPolicy invokes the viapi_regen.GetUploadPolicy API synchronously

func (*Client) GetUploadPolicyWithCallback 

func (client *Client) GetUploadPolicyWithCallback(request *GetUploadPolicyRequest, callback func(response *GetUploadPolicyResponse, err error)) <-chan int

GetUploadPolicyWithCallback invokes the viapi_regen.GetUploadPolicy API asynchronously

func (*Client) GetUploadPolicyWithChan 

func (client *Client) GetUploadPolicyWithChan(request *GetUploadPolicyRequest) (<-chan *GetUploadPolicyResponse, <-chan error)

GetUploadPolicyWithChan invokes the viapi_regen.GetUploadPolicy API asynchronously

func (*Client) GetUserInfo 

func (client *Client) GetUserInfo(request *GetUserInfoRequest) (response *GetUserInfoResponse, err error)

GetUserInfo invokes the viapi_regen.GetUserInfo API synchronously

func (*Client) GetUserInfoWithCallback 

func (client *Client) GetUserInfoWithCallback(request *GetUserInfoRequest, callback func(response *GetUserInfoResponse, err error)) <-chan int

GetUserInfoWithCallback invokes the viapi_regen.GetUserInfo API asynchronously

func (*Client) GetUserInfoWithChan 

func (client *Client) GetUserInfoWithChan(request *GetUserInfoRequest) (<-chan *GetUserInfoResponse, <-chan error)

GetUserInfoWithChan invokes the viapi_regen.GetUserInfo API asynchronously

func (*Client) GetWorkspace 

func (client *Client) GetWorkspace(request *GetWorkspaceRequest) (response *GetWorkspaceResponse, err error)

GetWorkspace invokes the viapi_regen.GetWorkspace API synchronously

func (*Client) GetWorkspaceWithCallback 

func (client *Client) GetWorkspaceWithCallback(request *GetWorkspaceRequest, callback func(response *GetWorkspaceResponse, err error)) <-chan int

GetWorkspaceWithCallback invokes the viapi_regen.GetWorkspace API asynchronously

func (*Client) GetWorkspaceWithChan 

func (client *Client) GetWorkspaceWithChan(request *GetWorkspaceRequest) (<-chan *GetWorkspaceResponse, <-chan error)

GetWorkspaceWithChan invokes the viapi_regen.GetWorkspace API asynchronously

func (*Client) ListDataReflowDatas 

func (client *Client) ListDataReflowDatas(request *ListDataReflowDatasRequest) (response *ListDataReflowDatasResponse, err error)

ListDataReflowDatas invokes the viapi_regen.ListDataReflowDatas API synchronously

func (*Client) ListDataReflowDatasWithCallback 

func (client *Client) ListDataReflowDatasWithCallback(request *ListDataReflowDatasRequest, callback func(response *ListDataReflowDatasResponse, err error)) <-chan int

ListDataReflowDatasWithCallback invokes the viapi_regen.ListDataReflowDatas API asynchronously

func (*Client) ListDataReflowDatasWithChan 

func (client *Client) ListDataReflowDatasWithChan(request *ListDataReflowDatasRequest) (<-chan *ListDataReflowDatasResponse, <-chan error)

ListDataReflowDatasWithChan invokes the viapi_regen.ListDataReflowDatas API asynchronously

func (*Client) ListDatasetDatas 

func (client *Client) ListDatasetDatas(request *ListDatasetDatasRequest) (response *ListDatasetDatasResponse, err error)

ListDatasetDatas invokes the viapi_regen.ListDatasetDatas API synchronously

func (*Client) ListDatasetDatasWithCallback 

func (client *Client) ListDatasetDatasWithCallback(request *ListDatasetDatasRequest, callback func(response *ListDatasetDatasResponse, err error)) <-chan int

ListDatasetDatasWithCallback invokes the viapi_regen.ListDatasetDatas API asynchronously

func (*Client) ListDatasetDatasWithChan 

func (client *Client) ListDatasetDatasWithChan(request *ListDatasetDatasRequest) (<-chan *ListDatasetDatasResponse, <-chan error)

ListDatasetDatasWithChan invokes the viapi_regen.ListDatasetDatas API asynchronously

func (*Client) ListDatasets 

func (client *Client) ListDatasets(request *ListDatasetsRequest) (response *ListDatasetsResponse, err error)

ListDatasets invokes the viapi_regen.ListDatasets API synchronously

func (*Client) ListDatasetsWithCallback 

func (client *Client) ListDatasetsWithCallback(request *ListDatasetsRequest, callback func(response *ListDatasetsResponse, err error)) <-chan int

ListDatasetsWithCallback invokes the viapi_regen.ListDatasets API asynchronously

func (*Client) ListDatasetsWithChan 

func (client *Client) ListDatasetsWithChan(request *ListDatasetsRequest) (<-chan *ListDatasetsResponse, <-chan error)

ListDatasetsWithChan invokes the viapi_regen.ListDatasets API asynchronously

func (*Client) ListLabelsetDatas 

func (client *Client) ListLabelsetDatas(request *ListLabelsetDatasRequest) (response *ListLabelsetDatasResponse, err error)

ListLabelsetDatas invokes the viapi_regen.ListLabelsetDatas API synchronously

func (*Client) ListLabelsetDatasWithCallback 

func (client *Client) ListLabelsetDatasWithCallback(request *ListLabelsetDatasRequest, callback func(response *ListLabelsetDatasResponse, err error)) <-chan int

ListLabelsetDatasWithCallback invokes the viapi_regen.ListLabelsetDatas API asynchronously

func (*Client) ListLabelsetDatasWithChan 

func (client *Client) ListLabelsetDatasWithChan(request *ListLabelsetDatasRequest) (<-chan *ListLabelsetDatasResponse, <-chan error)

ListLabelsetDatasWithChan invokes the viapi_regen.ListLabelsetDatas API asynchronously

func (*Client) ListLabelsets 

func (client *Client) ListLabelsets(request *ListLabelsetsRequest) (response *ListLabelsetsResponse, err error)

ListLabelsets invokes the viapi_regen.ListLabelsets API synchronously

func (*Client) ListLabelsetsWithCallback 

func (client *Client) ListLabelsetsWithCallback(request *ListLabelsetsRequest, callback func(response *ListLabelsetsResponse, err error)) <-chan int

ListLabelsetsWithCallback invokes the viapi_regen.ListLabelsets API asynchronously

func (*Client) ListLabelsetsWithChan 

func (client *Client) ListLabelsetsWithChan(request *ListLabelsetsRequest) (<-chan *ListLabelsetsResponse, <-chan error)

ListLabelsetsWithChan invokes the viapi_regen.ListLabelsets API asynchronously

func (*Client) ListServices 

func (client *Client) ListServices(request *ListServicesRequest) (response *ListServicesResponse, err error)

ListServices invokes the viapi_regen.ListServices API synchronously

func (*Client) ListServicesWithCallback 

func (client *Client) ListServicesWithCallback(request *ListServicesRequest, callback func(response *ListServicesResponse, err error)) <-chan int

ListServicesWithCallback invokes the viapi_regen.ListServices API asynchronously

func (*Client) ListServicesWithChan 

func (client *Client) ListServicesWithChan(request *ListServicesRequest) (<-chan *ListServicesResponse, <-chan error)

ListServicesWithChan invokes the viapi_regen.ListServices API asynchronously

func (*Client) ListTrainTasks 

func (client *Client) ListTrainTasks(request *ListTrainTasksRequest) (response *ListTrainTasksResponse, err error)

ListTrainTasks invokes the viapi_regen.ListTrainTasks API synchronously

func (*Client) ListTrainTasksWithCallback 

func (client *Client) ListTrainTasksWithCallback(request *ListTrainTasksRequest, callback func(response *ListTrainTasksResponse, err error)) <-chan int

ListTrainTasksWithCallback invokes the viapi_regen.ListTrainTasks API asynchronously

func (*Client) ListTrainTasksWithChan 

func (client *Client) ListTrainTasksWithChan(request *ListTrainTasksRequest) (<-chan *ListTrainTasksResponse, <-chan error)

ListTrainTasksWithChan invokes the viapi_regen.ListTrainTasks API asynchronously

func (*Client) ListWorkspaces 

func (client *Client) ListWorkspaces(request *ListWorkspacesRequest) (response *ListWorkspacesResponse, err error)

ListWorkspaces invokes the viapi_regen.ListWorkspaces API synchronously

func (*Client) ListWorkspacesWithCallback 

func (client *Client) ListWorkspacesWithCallback(request *ListWorkspacesRequest, callback func(response *ListWorkspacesResponse, err error)) <-chan int

ListWorkspacesWithCallback invokes the viapi_regen.ListWorkspaces API asynchronously

func (*Client) ListWorkspacesWithChan 

func (client *Client) ListWorkspacesWithChan(request *ListWorkspacesRequest) (<-chan *ListWorkspacesResponse, <-chan error)

ListWorkspacesWithChan invokes the viapi_regen.ListWorkspaces API asynchronously

func (*Client) SetDatasetUserOssPath 

func (client *Client) SetDatasetUserOssPath(request *SetDatasetUserOssPathRequest) (response *SetDatasetUserOssPathResponse, err error)

SetDatasetUserOssPath invokes the viapi_regen.SetDatasetUserOssPath API synchronously

func (*Client) SetDatasetUserOssPathWithCallback 

func (client *Client) SetDatasetUserOssPathWithCallback(request *SetDatasetUserOssPathRequest, callback func(response *SetDatasetUserOssPathResponse, err error)) <-chan int

SetDatasetUserOssPathWithCallback invokes the viapi_regen.SetDatasetUserOssPath API asynchronously

func (*Client) SetDatasetUserOssPathWithChan 

func (client *Client) SetDatasetUserOssPathWithChan(request *SetDatasetUserOssPathRequest) (<-chan *SetDatasetUserOssPathResponse, <-chan error)

SetDatasetUserOssPathWithChan invokes the viapi_regen.SetDatasetUserOssPath API asynchronously

func (*Client) StartService 

func (client *Client) StartService(request *StartServiceRequest) (response *StartServiceResponse, err error)

StartService invokes the viapi_regen.StartService API synchronously

func (*Client) StartServiceWithCallback 

func (client *Client) StartServiceWithCallback(request *StartServiceRequest, callback func(response *StartServiceResponse, err error)) <-chan int

StartServiceWithCallback invokes the viapi_regen.StartService API asynchronously

func (*Client) StartServiceWithChan 

func (client *Client) StartServiceWithChan(request *StartServiceRequest) (<-chan *StartServiceResponse, <-chan error)

StartServiceWithChan invokes the viapi_regen.StartService API asynchronously

func (*Client) StartTrainTask 

func (client *Client) StartTrainTask(request *StartTrainTaskRequest) (response *StartTrainTaskResponse, err error)

StartTrainTask invokes the viapi_regen.StartTrainTask API synchronously

func (*Client) StartTrainTaskWithCallback 

func (client *Client) StartTrainTaskWithCallback(request *StartTrainTaskRequest, callback func(response *StartTrainTaskResponse, err error)) <-chan int

StartTrainTaskWithCallback invokes the viapi_regen.StartTrainTask API asynchronously

func (*Client) StartTrainTaskWithChan 

func (client *Client) StartTrainTaskWithChan(request *StartTrainTaskRequest) (<-chan *StartTrainTaskResponse, <-chan error)

StartTrainTaskWithChan invokes the viapi_regen.StartTrainTask API asynchronously

func (*Client) StopService 

func (client *Client) StopService(request *StopServiceRequest) (response *StopServiceResponse, err error)

StopService invokes the viapi_regen.StopService API synchronously

func (*Client) StopServiceWithCallback 

func (client *Client) StopServiceWithCallback(request *StopServiceRequest, callback func(response *StopServiceResponse, err error)) <-chan int

StopServiceWithCallback invokes the viapi_regen.StopService API asynchronously

func (*Client) StopServiceWithChan 

func (client *Client) StopServiceWithChan(request *StopServiceRequest) (<-chan *StopServiceResponse, <-chan error)

StopServiceWithChan invokes the viapi_regen.StopService API asynchronously

func (*Client) StopTrainTask 

func (client *Client) StopTrainTask(request *StopTrainTaskRequest) (response *StopTrainTaskResponse, err error)

StopTrainTask invokes the viapi_regen.StopTrainTask API synchronously

func (*Client) StopTrainTaskWithCallback 

func (client *Client) StopTrainTaskWithCallback(request *StopTrainTaskRequest, callback func(response *StopTrainTaskResponse, err error)) <-chan int

StopTrainTaskWithCallback invokes the viapi_regen.StopTrainTask API asynchronously

func (*Client) StopTrainTaskWithChan 

func (client *Client) StopTrainTaskWithChan(request *StopTrainTaskRequest) (<-chan *StopTrainTaskResponse, <-chan error)

StopTrainTaskWithChan invokes the viapi_regen.StopTrainTask API asynchronously

func (*Client) UpdateDataset 

func (client *Client) UpdateDataset(request *UpdateDatasetRequest) (response *UpdateDatasetResponse, err error)

UpdateDataset invokes the viapi_regen.UpdateDataset API synchronously

func (*Client) UpdateDatasetWithCallback 

func (client *Client) UpdateDatasetWithCallback(request *UpdateDatasetRequest, callback func(response *UpdateDatasetResponse, err error)) <-chan int

UpdateDatasetWithCallback invokes the viapi_regen.UpdateDataset API asynchronously

func (*Client) UpdateDatasetWithChan 

func (client *Client) UpdateDatasetWithChan(request *UpdateDatasetRequest) (<-chan *UpdateDatasetResponse, <-chan error)

UpdateDatasetWithChan invokes the viapi_regen.UpdateDataset API asynchronously

func (*Client) UpdateLabelset 

func (client *Client) UpdateLabelset(request *UpdateLabelsetRequest) (response *UpdateLabelsetResponse, err error)

UpdateLabelset invokes the viapi_regen.UpdateLabelset API synchronously

func (*Client) UpdateLabelsetWithCallback 

func (client *Client) UpdateLabelsetWithCallback(request *UpdateLabelsetRequest, callback func(response *UpdateLabelsetResponse, err error)) <-chan int

UpdateLabelsetWithCallback invokes the viapi_regen.UpdateLabelset API asynchronously

func (*Client) UpdateLabelsetWithChan 

func (client *Client) UpdateLabelsetWithChan(request *UpdateLabelsetRequest) (<-chan *UpdateLabelsetResponse, <-chan error)

UpdateLabelsetWithChan invokes the viapi_regen.UpdateLabelset API asynchronously

func (*Client) UpdateService 

func (client *Client) UpdateService(request *UpdateServiceRequest) (response *UpdateServiceResponse, err error)

UpdateService invokes the viapi_regen.UpdateService API synchronously

func (*Client) UpdateServiceWithCallback 

func (client *Client) UpdateServiceWithCallback(request *UpdateServiceRequest, callback func(response *UpdateServiceResponse, err error)) <-chan int

UpdateServiceWithCallback invokes the viapi_regen.UpdateService API asynchronously

func (*Client) UpdateServiceWithChan 

func (client *Client) UpdateServiceWithChan(request *UpdateServiceRequest) (<-chan *UpdateServiceResponse, <-chan error)

UpdateServiceWithChan invokes the viapi_regen.UpdateService API asynchronously

func (*Client) UpdateTrainTask 

func (client *Client) UpdateTrainTask(request *UpdateTrainTaskRequest) (response *UpdateTrainTaskResponse, err error)

UpdateTrainTask invokes the viapi_regen.UpdateTrainTask API synchronously

func (*Client) UpdateTrainTaskWithCallback 

func (client *Client) UpdateTrainTaskWithCallback(request *UpdateTrainTaskRequest, callback func(response *UpdateTrainTaskResponse, err error)) <-chan int

UpdateTrainTaskWithCallback invokes the viapi_regen.UpdateTrainTask API asynchronously

func (*Client) UpdateTrainTaskWithChan 

func (client *Client) UpdateTrainTaskWithChan(request *UpdateTrainTaskRequest) (<-chan *UpdateTrainTaskResponse, <-chan error)

UpdateTrainTaskWithChan invokes the viapi_regen.UpdateTrainTask API asynchronously

func (*Client) UpdateWorkspace 

func (client *Client) UpdateWorkspace(request *UpdateWorkspaceRequest) (response *UpdateWorkspaceResponse, err error)

UpdateWorkspace invokes the viapi_regen.UpdateWorkspace API synchronously

func (*Client) UpdateWorkspaceWithCallback 

func (client *Client) UpdateWorkspaceWithCallback(request *UpdateWorkspaceRequest, callback func(response *UpdateWorkspaceResponse, err error)) <-chan int

UpdateWorkspaceWithCallback invokes the viapi_regen.UpdateWorkspace API asynchronously

func (*Client) UpdateWorkspaceWithChan 

func (client *Client) UpdateWorkspaceWithChan(request *UpdateWorkspaceRequest) (<-chan *UpdateWorkspaceResponse, <-chan error)

UpdateWorkspaceWithChan invokes the viapi_regen.UpdateWorkspace API asynchronously

type Contours 

type Contours struct {
	ContoursItem []ContoursItem `json:"contours" xml:"contours"`
}

Contours is a nested struct in viapi_regen response

type ContoursItem 

type ContoursItem struct {
	X int `json:"X" xml:"X"`
	Y int `json:"Y" xml:"Y"`
}

ContoursItem is a nested struct in viapi_regen response

type CreateDatasetRequest 

type CreateDatasetRequest struct {
	*requests.RpcRequest
	Description string           `position:"Body" name:"Description"`
	Type        string           `position:"Body" name:"Type"`
	Name        string           `position:"Body" name:"Name"`
	WorkspaceId requests.Integer `position:"Body" name:"WorkspaceId"`
}

CreateDatasetRequest is the request struct for api CreateDataset

func CreateCreateDatasetRequest 

func CreateCreateDatasetRequest() (request *CreateDatasetRequest)

CreateCreateDatasetRequest creates a request to invoke CreateDataset API

type CreateDatasetResponse 

type CreateDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateDatasetResponse is the response struct for api CreateDataset

func CreateCreateDatasetResponse 

func CreateCreateDatasetResponse() (response *CreateDatasetResponse)

CreateCreateDatasetResponse creates a response to parse from CreateDataset response

type CreateLabelsetRequest 

type CreateLabelsetRequest struct {
	*requests.RpcRequest
	Description string           `position:"Body" name:"Description"`
	Type        string           `position:"Body" name:"Type"`
	PreLabelId  requests.Integer `position:"Body" name:"PreLabelId"`
	TagUserList string           `position:"Body" name:"TagUserList"`
	UserOssUrl  string           `position:"Body" name:"UserOssUrl"`
	ObjectKey   string           `position:"Body" name:"ObjectKey"`
	Name        string           `position:"Body" name:"Name"`
	DatasetId   requests.Integer `position:"Body" name:"DatasetId"`
	TagSettings string           `position:"Body" name:"TagSettings"`
}

CreateLabelsetRequest is the request struct for api CreateLabelset

func CreateCreateLabelsetRequest 

func CreateCreateLabelsetRequest() (request *CreateLabelsetRequest)

CreateCreateLabelsetRequest creates a request to invoke CreateLabelset API

type CreateLabelsetResponse 

type CreateLabelsetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateLabelsetResponse is the response struct for api CreateLabelset

func CreateCreateLabelsetResponse 

func CreateCreateLabelsetResponse() (response *CreateLabelsetResponse)

CreateCreateLabelsetResponse creates a response to parse from CreateLabelset response

type CreateServiceRequest 

type CreateServiceRequest struct {
	*requests.RpcRequest
	Description       string           `position:"Body" name:"Description"`
	TrainTaskId       requests.Integer `position:"Body" name:"TrainTaskId"`
	AuthorizationType string           `position:"Body" name:"AuthorizationType"`
	Name              string           `position:"Body" name:"Name"`
	AuthorizedAccount string           `position:"Body" name:"AuthorizedAccount"`
}

CreateServiceRequest is the request struct for api CreateService

func CreateCreateServiceRequest 

func CreateCreateServiceRequest() (request *CreateServiceRequest)

CreateCreateServiceRequest creates a request to invoke CreateService API

type CreateServiceResponse 

type CreateServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateServiceResponse is the response struct for api CreateService

func CreateCreateServiceResponse 

func CreateCreateServiceResponse() (response *CreateServiceResponse)

CreateCreateServiceResponse creates a response to parse from CreateService response

type CreateTagTaskRequest 

type CreateTagTaskRequest struct {
	*requests.RpcRequest
	LabelsetId requests.Integer `position:"Body" name:"LabelsetId"`
}

CreateTagTaskRequest is the request struct for api CreateTagTask

func CreateCreateTagTaskRequest 

func CreateCreateTagTaskRequest() (request *CreateTagTaskRequest)

CreateCreateTagTaskRequest creates a request to invoke CreateTagTask API

type CreateTagTaskResponse 

type CreateTagTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateTagTaskResponse is the response struct for api CreateTagTask

func CreateCreateTagTaskResponse 

func CreateCreateTagTaskResponse() (response *CreateTagTaskResponse)

CreateCreateTagTaskResponse creates a response to parse from CreateTagTask response

type CreateTrainTaskRequest 

type CreateTrainTaskRequest struct {
	*requests.RpcRequest
	Description        string           `position:"Body" name:"Description"`
	TrainMode          string           `position:"Body" name:"TrainMode"`
	DatasetIds         string           `position:"Body" name:"DatasetIds"`
	PreTrainTaskId     requests.Integer `position:"Body" name:"PreTrainTaskId"`
	AdvancedParameters string           `position:"Body" name:"AdvancedParameters"`
	LabelId            requests.Integer `position:"Body" name:"LabelId"`
	Name               string           `position:"Body" name:"Name"`
	DatasetId          requests.Integer `position:"Body" name:"DatasetId"`
	LabelIds           string           `position:"Body" name:"LabelIds"`
	WorkspaceId        requests.Integer `position:"Body" name:"WorkspaceId"`
}

CreateTrainTaskRequest is the request struct for api CreateTrainTask

func CreateCreateTrainTaskRequest 

func CreateCreateTrainTaskRequest() (request *CreateTrainTaskRequest)

CreateCreateTrainTaskRequest creates a request to invoke CreateTrainTask API

type CreateTrainTaskResponse 

type CreateTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateTrainTaskResponse is the response struct for api CreateTrainTask

func CreateCreateTrainTaskResponse 

func CreateCreateTrainTaskResponse() (response *CreateTrainTaskResponse)

CreateCreateTrainTaskResponse creates a response to parse from CreateTrainTask response

type CreateWorkspaceRequest 

type CreateWorkspaceRequest struct {
	*requests.RpcRequest
	Description string `position:"Body" name:"Description"`
	Type        string `position:"Body" name:"Type"`
	Name        string `position:"Body" name:"Name"`
}

CreateWorkspaceRequest is the request struct for api CreateWorkspace

func CreateCreateWorkspaceRequest 

func CreateCreateWorkspaceRequest() (request *CreateWorkspaceRequest)

CreateCreateWorkspaceRequest creates a request to invoke CreateWorkspace API

type CreateWorkspaceResponse 

type CreateWorkspaceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateWorkspaceResponse is the response struct for api CreateWorkspace

func CreateCreateWorkspaceResponse 

func CreateCreateWorkspaceResponse() (response *CreateWorkspaceResponse)

CreateCreateWorkspaceResponse creates a response to parse from CreateWorkspace response

type CustomizeClassifyImageRequest 

type CustomizeClassifyImageRequest struct {
	*requests.RpcRequest
	ImageUrl  string `position:"Body" name:"ImageUrl"`
	ServiceId string `position:"Body" name:"ServiceId"`
}

CustomizeClassifyImageRequest is the request struct for api CustomizeClassifyImage

func CreateCustomizeClassifyImageRequest 

func CreateCustomizeClassifyImageRequest() (request *CustomizeClassifyImageRequest)

CreateCustomizeClassifyImageRequest creates a request to invoke CustomizeClassifyImage API

type CustomizeClassifyImageResponse 

type CustomizeClassifyImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

CustomizeClassifyImageResponse is the response struct for api CustomizeClassifyImage

func CreateCustomizeClassifyImageResponse 

func CreateCustomizeClassifyImageResponse() (response *CustomizeClassifyImageResponse)

CreateCustomizeClassifyImageResponse creates a response to parse from CustomizeClassifyImage response

type CustomizeDetectImageRequest 

type CustomizeDetectImageRequest struct {
	*requests.RpcRequest
	ImageUrl  string `position:"Body" name:"ImageUrl"`
	ServiceId string `position:"Body" name:"ServiceId"`
}

CustomizeDetectImageRequest is the request struct for api CustomizeDetectImage

func CreateCustomizeDetectImageRequest 

func CreateCustomizeDetectImageRequest() (request *CustomizeDetectImageRequest)

CreateCustomizeDetectImageRequest creates a request to invoke CustomizeDetectImage API

type CustomizeDetectImageResponse 

type CustomizeDetectImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

CustomizeDetectImageResponse is the response struct for api CustomizeDetectImage

func CreateCustomizeDetectImageResponse 

func CreateCustomizeDetectImageResponse() (response *CustomizeDetectImageResponse)

CreateCustomizeDetectImageResponse creates a response to parse from CustomizeDetectImage response

type CustomizeInstanceSegmentImageRequest 

type CustomizeInstanceSegmentImageRequest struct {
	*requests.RpcRequest
	ImageUrl  string `position:"Body" name:"ImageUrl"`
	ServiceId string `position:"Body" name:"ServiceId"`
}

CustomizeInstanceSegmentImageRequest is the request struct for api CustomizeInstanceSegmentImage

func CreateCustomizeInstanceSegmentImageRequest 

func CreateCustomizeInstanceSegmentImageRequest() (request *CustomizeInstanceSegmentImageRequest)

CreateCustomizeInstanceSegmentImageRequest creates a request to invoke CustomizeInstanceSegmentImage API

type CustomizeInstanceSegmentImageResponse 

type CustomizeInstanceSegmentImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

CustomizeInstanceSegmentImageResponse is the response struct for api CustomizeInstanceSegmentImage

func CreateCustomizeInstanceSegmentImageResponse 

func CreateCustomizeInstanceSegmentImageResponse() (response *CustomizeInstanceSegmentImageResponse)

CreateCustomizeInstanceSegmentImageResponse creates a response to parse from CustomizeInstanceSegmentImage response

type Data 

type Data struct {
	OriginalFilename       string                 `json:"OriginalFilename" xml:"OriginalFilename"`
	ObjectKey              string                 `json:"ObjectKey" xml:"ObjectKey"`
	OssUrl                 string                 `json:"OssUrl" xml:"OssUrl"`
	ModelEffect            string                 `json:"ModelEffect" xml:"ModelEffect"`
	RelyOnTaskId           int64                  `json:"RelyOnTaskId" xml:"RelyOnTaskId"`
	ParentUid              string                 `json:"ParentUid" xml:"ParentUid"`
	SubTaskPackageSize     string                 `json:"SubTaskPackageSize" xml:"SubTaskPackageSize"`
	ServiceDescription     string                 `json:"ServiceDescription" xml:"ServiceDescription"`
	AuthorizationType      string                 `json:"AuthorizationType" xml:"AuthorizationType"`
	SimpleEvaluate         int64                  `json:"SimpleEvaluate" xml:"SimpleEvaluate"`
	ServiceName            string                 `json:"ServiceName" xml:"ServiceName"`
	FileName               string                 `json:"FileName" xml:"FileName"`
	UserQps                map[string]interface{} `json:"UserQps" xml:"UserQps"`
	Type                   string                 `json:"Type" xml:"Type"`
	TrainStatus            string                 `json:"TrainStatus" xml:"TrainStatus"`
	Tags                   string                 `json:"Tags" xml:"Tags"`
	SignedHttpUrl          string                 `json:"SignedHttpUrl" xml:"SignedHttpUrl"`
	Id                     int64                  `json:"Id" xml:"Id"`
	AccessId               string                 `json:"AccessId" xml:"AccessId"`
	ModelId                int64                  `json:"ModelId" xml:"ModelId"`
	GmtCreate              int64                  `json:"GmtCreate" xml:"GmtCreate"`
	UserType               string                 `json:"UserType" xml:"UserType"`
	RelyOnTaskName         string                 `json:"RelyOnTaskName" xml:"RelyOnTaskName"`
	AdvancedParameters     string                 `json:"AdvancedParameters" xml:"AdvancedParameters"`
	EnableDataReflowFlag   bool                   `json:"EnableDataReflowFlag" xml:"EnableDataReflowFlag"`
	CheckResult            map[string]interface{} `json:"CheckResult" xml:"CheckResult"`
	ServiceId              int64                  `json:"ServiceId" xml:"ServiceId"`
	GmtModified            int64                  `json:"GmtModified" xml:"GmtModified"`
	LabelType              string                 `json:"LabelType" xml:"LabelType"`
	DataReflowRate         int64                  `json:"DataReflowRate" xml:"DataReflowRate"`
	BucketName             string                 `json:"BucketName" xml:"BucketName"`
	Status                 string                 `json:"Status" xml:"Status"`
	LabelInfo              string                 `json:"LabelInfo" xml:"LabelInfo"`
	Name                   string                 `json:"Name" xml:"Name"`
	Category               string                 `json:"Category" xml:"Category"`
	EstimatedTime          string                 `json:"EstimatedTime" xml:"EstimatedTime"`
	DatasetId              int64                  `json:"DatasetId" xml:"DatasetId"`
	Score                  float64                `json:"Score" xml:"Score"`
	DataReflowOssPath      string                 `json:"DataReflowOssPath" xml:"DataReflowOssPath"`
	DiffCount              int64                  `json:"DiffCount" xml:"DiffCount"`
	Bucket                 string                 `json:"Bucket" xml:"Bucket"`
	Endpoint               string                 `json:"Endpoint" xml:"Endpoint"`
	TagUserList            string                 `json:"TagUserList" xml:"TagUserList"`
	FailureReason          string                 `json:"FailureReason" xml:"FailureReason"`
	OssBucketCORSConfigUrl string                 `json:"OssBucketCORSConfigUrl" xml:"OssBucketCORSConfigUrl"`
	OssHttpUrl             string                 `json:"OssHttpUrl" xml:"OssHttpUrl"`
	Description            string                 `json:"Description" xml:"Description"`
	Policy                 string                 `json:"Policy" xml:"Policy"`
	LabelId                int64                  `json:"LabelId" xml:"LabelId"`
	SetOssBucketCORSFlag   bool                   `json:"SetOssBucketCORSFlag" xml:"SetOssBucketCORSFlag"`
	AuthorizedAccount      string                 `json:"AuthorizedAccount" xml:"AuthorizedAccount"`
	DatasetName            string                 `json:"DatasetName" xml:"DatasetName"`
	TrainMode              string                 `json:"TrainMode" xml:"TrainMode"`
	UserInvoke             map[string]interface{} `json:"UserInvoke" xml:"UserInvoke"`
	Signature              string                 `json:"Signature" xml:"Signature"`
	LabelName              string                 `json:"LabelName" xml:"LabelName"`
	OwnerType              string                 `json:"OwnerType" xml:"OwnerType"`
	TaskName               string                 `json:"TaskName" xml:"TaskName"`
	Total                  int64                  `json:"Total" xml:"Total"`
	TrainUseTime           int64                  `json:"TrainUseTime" xml:"TrainUseTime"`
	Elements               []ElementsItem         `json:"Elements" xml:"Elements"`
}

Data is a nested struct in viapi_regen response

type DataInGetService 

type DataInGetService struct {
	Id                 int64          `json:"Id" xml:"Id"`
	GmtCreate          int64          `json:"GmtCreate" xml:"GmtCreate"`
	ServiceName        string         `json:"ServiceName" xml:"ServiceName"`
	ServiceDescription string         `json:"ServiceDescription" xml:"ServiceDescription"`
	Status             string         `json:"Status" xml:"Status"`
	ServiceId          string         `json:"ServiceId" xml:"ServiceId"`
	InputParams        string         `json:"InputParams" xml:"InputParams"`
	OutputParams       string         `json:"OutputParams" xml:"OutputParams"`
	Errorcodes         string         `json:"Errorcodes" xml:"Errorcodes"`
	InputExample       string         `json:"InputExample" xml:"InputExample"`
	OutputExample      string         `json:"OutputExample" xml:"OutputExample"`
	DataReflowInfo     DataReflowInfo `json:"DataReflowInfo" xml:"DataReflowInfo"`
}

DataInGetService is a nested struct in viapi_regen response

type DataInListDataReflowDatas 

type DataInListDataReflowDatas struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListDataReflowDatas is a nested struct in viapi_regen response

type DataInListDatasetDatas 

type DataInListDatasetDatas struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListDatasetDatas is a nested struct in viapi_regen response

type DataInListDatasets 

type DataInListDatasets struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListDatasets is a nested struct in viapi_regen response

type DataInListLabelsetDatas 

type DataInListLabelsetDatas struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListLabelsetDatas is a nested struct in viapi_regen response

type DataInListLabelsets 

type DataInListLabelsets struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListLabelsets is a nested struct in viapi_regen response

type DataInListServices 

type DataInListServices struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListServices is a nested struct in viapi_regen response

type DataInListTrainTasks 

type DataInListTrainTasks struct {
	CurrentPage int64                    `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64                    `json:"PageSize" xml:"PageSize"`
	TotalPage   int64                    `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64                    `json:"TotalCount" xml:"TotalCount"`
	Elements    []map[string]interface{} `json:"Elements" xml:"Elements"`
}

DataInListTrainTasks is a nested struct in viapi_regen response

type DataInListWorkspaces 

type DataInListWorkspaces struct {
	CurrentPage int64     `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int64     `json:"PageSize" xml:"PageSize"`
	TotalPage   int64     `json:"TotalPage" xml:"TotalPage"`
	TotalCount  int64     `json:"TotalCount" xml:"TotalCount"`
	Elements    []Element `json:"Elements" xml:"Elements"`
}

DataInListWorkspaces is a nested struct in viapi_regen response

type DataInUpdateLabelset 

type DataInUpdateLabelset struct {
	Id          int64 `json:"Id" xml:"Id"`
	GmtCreate   int64 `json:"GmtCreate" xml:"GmtCreate"`
	Name        int64 `json:"Name" xml:"Name"`
	Description int64 `json:"Description" xml:"Description"`
}

DataInUpdateLabelset is a nested struct in viapi_regen response

type DataReflowInfo 

type DataReflowInfo struct {
	DataReflowCount      int64  `json:"DataReflowCount" xml:"DataReflowCount"`
	DataReflowRate       int64  `json:"DataReflowRate" xml:"DataReflowRate"`
	DataReflowOssPath    string `json:"DataReflowOssPath" xml:"DataReflowOssPath"`
	EnableDataReflowFlag bool   `json:"EnableDataReflowFlag" xml:"EnableDataReflowFlag"`
}

DataReflowInfo is a nested struct in viapi_regen response

type DebugServiceRequest 

type DebugServiceRequest struct {
	*requests.RpcRequest
	Param string           `position:"Body" name:"Param"`
	Id    requests.Integer `position:"Body" name:"Id"`
}

DebugServiceRequest is the request struct for api DebugService

func CreateDebugServiceRequest 

func CreateDebugServiceRequest() (request *DebugServiceRequest)

CreateDebugServiceRequest creates a request to invoke DebugService API

type DebugServiceResponse 

type DebugServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      string `json:"Data" xml:"Data"`
	Code      string `json:"Code" xml:"Code"`
}

DebugServiceResponse is the response struct for api DebugService

func CreateDebugServiceResponse 

func CreateDebugServiceResponse() (response *DebugServiceResponse)

CreateDebugServiceResponse creates a response to parse from DebugService response

type DeleteDataReflowDataRequest 

type DeleteDataReflowDataRequest struct {
	*requests.RpcRequest
	Id        requests.Integer `position:"Body" name:"Id"`
	ServiceId requests.Integer `position:"Body" name:"ServiceId"`
}

DeleteDataReflowDataRequest is the request struct for api DeleteDataReflowData

func CreateDeleteDataReflowDataRequest 

func CreateDeleteDataReflowDataRequest() (request *DeleteDataReflowDataRequest)

CreateDeleteDataReflowDataRequest creates a request to invoke DeleteDataReflowData API

type DeleteDataReflowDataResponse 

type DeleteDataReflowDataResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteDataReflowDataResponse is the response struct for api DeleteDataReflowData

func CreateDeleteDataReflowDataResponse 

func CreateDeleteDataReflowDataResponse() (response *DeleteDataReflowDataResponse)

CreateDeleteDataReflowDataResponse creates a response to parse from DeleteDataReflowData response

type DeleteDatasetRequest 

type DeleteDatasetRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

DeleteDatasetRequest is the request struct for api DeleteDataset

func CreateDeleteDatasetRequest 

func CreateDeleteDatasetRequest() (request *DeleteDatasetRequest)

CreateDeleteDatasetRequest creates a request to invoke DeleteDataset API

type DeleteDatasetResponse 

type DeleteDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteDatasetResponse is the response struct for api DeleteDataset

func CreateDeleteDatasetResponse 

func CreateDeleteDatasetResponse() (response *DeleteDatasetResponse)

CreateDeleteDatasetResponse creates a response to parse from DeleteDataset response

type DeleteLabelsetDataRequest 

type DeleteLabelsetDataRequest struct {
	*requests.RpcRequest
	Id      requests.Integer `position:"Body" name:"Id"`
	LabelId requests.Integer `position:"Body" name:"LabelId"`
}

DeleteLabelsetDataRequest is the request struct for api DeleteLabelsetData

func CreateDeleteLabelsetDataRequest 

func CreateDeleteLabelsetDataRequest() (request *DeleteLabelsetDataRequest)

CreateDeleteLabelsetDataRequest creates a request to invoke DeleteLabelsetData API

type DeleteLabelsetDataResponse 

type DeleteLabelsetDataResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteLabelsetDataResponse is the response struct for api DeleteLabelsetData

func CreateDeleteLabelsetDataResponse 

func CreateDeleteLabelsetDataResponse() (response *DeleteLabelsetDataResponse)

CreateDeleteLabelsetDataResponse creates a response to parse from DeleteLabelsetData response

type DeleteLabelsetRequest 

type DeleteLabelsetRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

DeleteLabelsetRequest is the request struct for api DeleteLabelset

func CreateDeleteLabelsetRequest 

func CreateDeleteLabelsetRequest() (request *DeleteLabelsetRequest)

CreateDeleteLabelsetRequest creates a request to invoke DeleteLabelset API

type DeleteLabelsetResponse 

type DeleteLabelsetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteLabelsetResponse is the response struct for api DeleteLabelset

func CreateDeleteLabelsetResponse 

func CreateDeleteLabelsetResponse() (response *DeleteLabelsetResponse)

CreateDeleteLabelsetResponse creates a response to parse from DeleteLabelset response

type DeleteServiceRequest 

type DeleteServiceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

DeleteServiceRequest is the request struct for api DeleteService

func CreateDeleteServiceRequest 

func CreateDeleteServiceRequest() (request *DeleteServiceRequest)

CreateDeleteServiceRequest creates a request to invoke DeleteService API

type DeleteServiceResponse 

type DeleteServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteServiceResponse is the response struct for api DeleteService

func CreateDeleteServiceResponse 

func CreateDeleteServiceResponse() (response *DeleteServiceResponse)

CreateDeleteServiceResponse creates a response to parse from DeleteService response

type DeleteTrainTaskRequest 

type DeleteTrainTaskRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

DeleteTrainTaskRequest is the request struct for api DeleteTrainTask

func CreateDeleteTrainTaskRequest 

func CreateDeleteTrainTaskRequest() (request *DeleteTrainTaskRequest)

CreateDeleteTrainTaskRequest creates a request to invoke DeleteTrainTask API

type DeleteTrainTaskResponse 

type DeleteTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteTrainTaskResponse is the response struct for api DeleteTrainTask

func CreateDeleteTrainTaskResponse 

func CreateDeleteTrainTaskResponse() (response *DeleteTrainTaskResponse)

CreateDeleteTrainTaskResponse creates a response to parse from DeleteTrainTask response

type DeleteWorkspaceRequest 

type DeleteWorkspaceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

DeleteWorkspaceRequest is the request struct for api DeleteWorkspace

func CreateDeleteWorkspaceRequest 

func CreateDeleteWorkspaceRequest() (request *DeleteWorkspaceRequest)

CreateDeleteWorkspaceRequest creates a request to invoke DeleteWorkspace API

type DeleteWorkspaceResponse 

type DeleteWorkspaceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteWorkspaceResponse is the response struct for api DeleteWorkspace

func CreateDeleteWorkspaceResponse 

func CreateDeleteWorkspaceResponse() (response *DeleteWorkspaceResponse)

CreateDeleteWorkspaceResponse creates a response to parse from DeleteWorkspace response

type DisableDataReflowRequest 

type DisableDataReflowRequest struct {
	*requests.RpcRequest
	ServiceId requests.Integer `position:"Body" name:"ServiceId"`
}

DisableDataReflowRequest is the request struct for api DisableDataReflow

func CreateDisableDataReflowRequest 

func CreateDisableDataReflowRequest() (request *DisableDataReflowRequest)

CreateDisableDataReflowRequest creates a request to invoke DisableDataReflow API

type DisableDataReflowResponse 

type DisableDataReflowResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableDataReflowResponse is the response struct for api DisableDataReflow

func CreateDisableDataReflowResponse 

func CreateDisableDataReflowResponse() (response *DisableDataReflowResponse)

CreateDisableDataReflowResponse creates a response to parse from DisableDataReflow response

type DownloadDatasetRequest 

type DownloadDatasetRequest struct {
	*requests.RpcRequest
	DatasetId requests.Integer `position:"Body" name:"DatasetId"`
}

DownloadDatasetRequest is the request struct for api DownloadDataset

func CreateDownloadDatasetRequest 

func CreateDownloadDatasetRequest() (request *DownloadDatasetRequest)

CreateDownloadDatasetRequest creates a request to invoke DownloadDataset API

type DownloadDatasetResponse 

type DownloadDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DownloadDatasetResponse is the response struct for api DownloadDataset

func CreateDownloadDatasetResponse 

func CreateDownloadDatasetResponse() (response *DownloadDatasetResponse)

CreateDownloadDatasetResponse creates a response to parse from DownloadDataset response

type DownloadFileNameListRequest 

type DownloadFileNameListRequest struct {
	*requests.RpcRequest
	Identity  string           `position:"Body" name:"Identity"`
	DatasetId requests.Integer `position:"Body" name:"DatasetId"`
}

DownloadFileNameListRequest is the request struct for api DownloadFileNameList

func CreateDownloadFileNameListRequest 

func CreateDownloadFileNameListRequest() (request *DownloadFileNameListRequest)

CreateDownloadFileNameListRequest creates a request to invoke DownloadFileNameList API

type DownloadFileNameListResponse 

type DownloadFileNameListResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DownloadFileNameListResponse is the response struct for api DownloadFileNameList

func CreateDownloadFileNameListResponse 

func CreateDownloadFileNameListResponse() (response *DownloadFileNameListResponse)

CreateDownloadFileNameListResponse creates a response to parse from DownloadFileNameList response

type DownloadLabelFileRequest 

type DownloadLabelFileRequest struct {
	*requests.RpcRequest
	LabelId requests.Integer `position:"Body" name:"LabelId"`
}

DownloadLabelFileRequest is the request struct for api DownloadLabelFile

func CreateDownloadLabelFileRequest 

func CreateDownloadLabelFileRequest() (request *DownloadLabelFileRequest)

CreateDownloadLabelFileRequest creates a request to invoke DownloadLabelFile API

type DownloadLabelFileResponse 

type DownloadLabelFileResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

DownloadLabelFileResponse is the response struct for api DownloadLabelFile

func CreateDownloadLabelFileResponse 

func CreateDownloadLabelFileResponse() (response *DownloadLabelFileResponse)

CreateDownloadLabelFileResponse creates a response to parse from DownloadLabelFile response

type Element 

type Element struct {
	Id          int64  `json:"Id" xml:"Id"`
	GmtCreate   int64  `json:"GmtCreate" xml:"GmtCreate"`
	Name        string `json:"Name" xml:"Name"`
	Description string `json:"Description" xml:"Description"`
	Type        string `json:"Type" xml:"Type"`
}

Element is a nested struct in viapi_regen response

type ElementsInCustomizeDetectImage 

type ElementsInCustomizeDetectImage struct {
	ElementsItem []ElementsItem `json:"elements" xml:"elements"`
}

ElementsInCustomizeDetectImage is a nested struct in viapi_regen response

type ElementsInCustomizeInstanceSegmentImage 

type ElementsInCustomizeInstanceSegmentImage struct {
	ElementsItem []ElementsItem `json:"elements" xml:"elements"`
}

ElementsInCustomizeInstanceSegmentImage is a nested struct in viapi_regen response

type ElementsInListDataReflowDatas 

type ElementsInListDataReflowDatas struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListDataReflowDatas is a nested struct in viapi_regen response

type ElementsInListDatasetDatas 

type ElementsInListDatasetDatas struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListDatasetDatas is a nested struct in viapi_regen response

type ElementsInListDatasets 

type ElementsInListDatasets struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListDatasets is a nested struct in viapi_regen response

type ElementsInListLabelsetDatas 

type ElementsInListLabelsetDatas struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListLabelsetDatas is a nested struct in viapi_regen response

type ElementsInListLabelsets 

type ElementsInListLabelsets struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListLabelsets is a nested struct in viapi_regen response

type ElementsInListServices 

type ElementsInListServices struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListServices is a nested struct in viapi_regen response

type ElementsInListTrainTasks 

type ElementsInListTrainTasks struct {
	Element []map[string]interface{} `json:"element" xml:"element"`
}

ElementsInListTrainTasks is a nested struct in viapi_regen response

type ElementsInListWorkspaces 

type ElementsInListWorkspaces struct {
	Element []Element `json:"element" xml:"element"`
}

ElementsInListWorkspaces is a nested struct in viapi_regen response

type ElementsItem 

type ElementsItem struct {
	Category string                               `json:"Category" xml:"Category"`
	Score    float64                              `json:"Score" xml:"Score"`
	Mask     Mask                                 `json:"Mask" xml:"Mask"`
	Boxes    BoxesInCustomizeInstanceSegmentImage `json:"Boxes" xml:"Boxes"`
	Contours []ContoursItem                       `json:"Contours" xml:"Contours"`
}

ElementsItem is a nested struct in viapi_regen response

type EnableDataReflowRequest 

type EnableDataReflowRequest struct {
	*requests.RpcRequest
	DataReflowRate    requests.Integer `position:"Body" name:"DataReflowRate"`
	DataReflowOssPath string           `position:"Body" name:"DataReflowOssPath"`
	ServiceId         requests.Integer `position:"Body" name:"ServiceId"`
}

EnableDataReflowRequest is the request struct for api EnableDataReflow

func CreateEnableDataReflowRequest 

func CreateEnableDataReflowRequest() (request *EnableDataReflowRequest)

CreateEnableDataReflowRequest creates a request to invoke EnableDataReflow API

type EnableDataReflowResponse 

type EnableDataReflowResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableDataReflowResponse is the response struct for api EnableDataReflow

func CreateEnableDataReflowResponse 

func CreateEnableDataReflowResponse() (response *EnableDataReflowResponse)

CreateEnableDataReflowResponse creates a response to parse from EnableDataReflow response

type ExportDataReflowDataListRequest 

type ExportDataReflowDataListRequest struct {
	*requests.RpcRequest
	FileType  string           `position:"Body" name:"FileType"`
	StartTime requests.Integer `position:"Body" name:"StartTime"`
	ImageName string           `position:"Body" name:"ImageName"`
	EndTime   requests.Integer `position:"Body" name:"EndTime"`
	ServiceId requests.Integer `position:"Body" name:"ServiceId"`
	Category  string           `position:"Body" name:"Category"`
}

ExportDataReflowDataListRequest is the request struct for api ExportDataReflowDataList

func CreateExportDataReflowDataListRequest 

func CreateExportDataReflowDataListRequest() (request *ExportDataReflowDataListRequest)

CreateExportDataReflowDataListRequest creates a request to invoke ExportDataReflowDataList API

type ExportDataReflowDataListResponse 

type ExportDataReflowDataListResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

ExportDataReflowDataListResponse is the response struct for api ExportDataReflowDataList

func CreateExportDataReflowDataListResponse 

func CreateExportDataReflowDataListResponse() (response *ExportDataReflowDataListResponse)

CreateExportDataReflowDataListResponse creates a response to parse from ExportDataReflowDataList response

type GetDatasetRequest 

type GetDatasetRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetDatasetRequest is the request struct for api GetDataset

func CreateGetDatasetRequest 

func CreateGetDatasetRequest() (request *GetDatasetRequest)

CreateGetDatasetRequest creates a request to invoke GetDataset API

type GetDatasetResponse 

type GetDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetDatasetResponse is the response struct for api GetDataset

func CreateGetDatasetResponse 

func CreateGetDatasetResponse() (response *GetDatasetResponse)

CreateGetDatasetResponse creates a response to parse from GetDataset response

type GetDiffCountLabelsetAndDatasetRequest 

type GetDiffCountLabelsetAndDatasetRequest struct {
	*requests.RpcRequest
	LabelsetId requests.Integer `position:"Body" name:"LabelsetId"`
}

GetDiffCountLabelsetAndDatasetRequest is the request struct for api GetDiffCountLabelsetAndDataset

func CreateGetDiffCountLabelsetAndDatasetRequest 

func CreateGetDiffCountLabelsetAndDatasetRequest() (request *GetDiffCountLabelsetAndDatasetRequest)

CreateGetDiffCountLabelsetAndDatasetRequest creates a request to invoke GetDiffCountLabelsetAndDataset API

type GetDiffCountLabelsetAndDatasetResponse 

type GetDiffCountLabelsetAndDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetDiffCountLabelsetAndDatasetResponse is the response struct for api GetDiffCountLabelsetAndDataset

func CreateGetDiffCountLabelsetAndDatasetResponse 

func CreateGetDiffCountLabelsetAndDatasetResponse() (response *GetDiffCountLabelsetAndDatasetResponse)

CreateGetDiffCountLabelsetAndDatasetResponse creates a response to parse from GetDiffCountLabelsetAndDataset response

type GetLabelDetailRequest 

type GetLabelDetailRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetLabelDetailRequest is the request struct for api GetLabelDetail

func CreateGetLabelDetailRequest 

func CreateGetLabelDetailRequest() (request *GetLabelDetailRequest)

CreateGetLabelDetailRequest creates a request to invoke GetLabelDetail API

type GetLabelDetailResponse 

type GetLabelDetailResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetLabelDetailResponse is the response struct for api GetLabelDetail

func CreateGetLabelDetailResponse 

func CreateGetLabelDetailResponse() (response *GetLabelDetailResponse)

CreateGetLabelDetailResponse creates a response to parse from GetLabelDetail response

type GetLabelsetRequest 

type GetLabelsetRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetLabelsetRequest is the request struct for api GetLabelset

func CreateGetLabelsetRequest 

func CreateGetLabelsetRequest() (request *GetLabelsetRequest)

CreateGetLabelsetRequest creates a request to invoke GetLabelset API

type GetLabelsetResponse 

type GetLabelsetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetLabelsetResponse is the response struct for api GetLabelset

func CreateGetLabelsetResponse 

func CreateGetLabelsetResponse() (response *GetLabelsetResponse)

CreateGetLabelsetResponse creates a response to parse from GetLabelset response

type GetServiceInvokeRequest 

type GetServiceInvokeRequest struct {
	*requests.RpcRequest
	StartTime          requests.Integer `position:"Body" name:"StartTime"`
	Id                 requests.Integer `position:"Body" name:"Id"`
	EndTime            requests.Integer `position:"Body" name:"EndTime"`
	CallerParentIdList *[]string        `position:"Body" name:"CallerParentIdList"  type:"Json"`
}

GetServiceInvokeRequest is the request struct for api GetServiceInvoke

func CreateGetServiceInvokeRequest 

func CreateGetServiceInvokeRequest() (request *GetServiceInvokeRequest)

CreateGetServiceInvokeRequest creates a request to invoke GetServiceInvoke API

type GetServiceInvokeResponse 

type GetServiceInvokeResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetServiceInvokeResponse is the response struct for api GetServiceInvoke

func CreateGetServiceInvokeResponse 

func CreateGetServiceInvokeResponse() (response *GetServiceInvokeResponse)

CreateGetServiceInvokeResponse creates a response to parse from GetServiceInvoke response

type GetServiceQpsRequest 

type GetServiceQpsRequest struct {
	*requests.RpcRequest
	StartTime          requests.Integer `position:"Body" name:"StartTime"`
	Id                 requests.Integer `position:"Body" name:"Id"`
	EndTime            requests.Integer `position:"Body" name:"EndTime"`
	CallerParentIdList *[]string        `position:"Body" name:"CallerParentIdList"  type:"Json"`
}

GetServiceQpsRequest is the request struct for api GetServiceQps

func CreateGetServiceQpsRequest 

func CreateGetServiceQpsRequest() (request *GetServiceQpsRequest)

CreateGetServiceQpsRequest creates a request to invoke GetServiceQps API

type GetServiceQpsResponse 

type GetServiceQpsResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetServiceQpsResponse is the response struct for api GetServiceQps

func CreateGetServiceQpsResponse 

func CreateGetServiceQpsResponse() (response *GetServiceQpsResponse)

CreateGetServiceQpsResponse creates a response to parse from GetServiceQps response

type GetServiceRequest 

type GetServiceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetServiceRequest is the request struct for api GetService

func CreateGetServiceRequest 

func CreateGetServiceRequest() (request *GetServiceRequest)

CreateGetServiceRequest creates a request to invoke GetService API

type GetServiceResponse 

type GetServiceResponse struct {
	*responses.BaseResponse
	Message   string           `json:"Message" xml:"Message"`
	RequestId string           `json:"RequestId" xml:"RequestId"`
	Code      string           `json:"Code" xml:"Code"`
	Data      DataInGetService `json:"Data" xml:"Data"`
}

GetServiceResponse is the response struct for api GetService

func CreateGetServiceResponse 

func CreateGetServiceResponse() (response *GetServiceResponse)

CreateGetServiceResponse creates a response to parse from GetService response

type GetTrainModelRequest 

type GetTrainModelRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetTrainModelRequest is the request struct for api GetTrainModel

func CreateGetTrainModelRequest 

func CreateGetTrainModelRequest() (request *GetTrainModelRequest)

CreateGetTrainModelRequest creates a request to invoke GetTrainModel API

type GetTrainModelResponse 

type GetTrainModelResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetTrainModelResponse is the response struct for api GetTrainModel

func CreateGetTrainModelResponse 

func CreateGetTrainModelResponse() (response *GetTrainModelResponse)

CreateGetTrainModelResponse creates a response to parse from GetTrainModel response

type GetTrainTaskEstimatedTimeRequest 

type GetTrainTaskEstimatedTimeRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetTrainTaskEstimatedTimeRequest is the request struct for api GetTrainTaskEstimatedTime

func CreateGetTrainTaskEstimatedTimeRequest 

func CreateGetTrainTaskEstimatedTimeRequest() (request *GetTrainTaskEstimatedTimeRequest)

CreateGetTrainTaskEstimatedTimeRequest creates a request to invoke GetTrainTaskEstimatedTime API

type GetTrainTaskEstimatedTimeResponse 

type GetTrainTaskEstimatedTimeResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetTrainTaskEstimatedTimeResponse is the response struct for api GetTrainTaskEstimatedTime

func CreateGetTrainTaskEstimatedTimeResponse 

func CreateGetTrainTaskEstimatedTimeResponse() (response *GetTrainTaskEstimatedTimeResponse)

CreateGetTrainTaskEstimatedTimeResponse creates a response to parse from GetTrainTaskEstimatedTime response

type GetTrainTaskRequest 

type GetTrainTaskRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetTrainTaskRequest is the request struct for api GetTrainTask

func CreateGetTrainTaskRequest 

func CreateGetTrainTaskRequest() (request *GetTrainTaskRequest)

CreateGetTrainTaskRequest creates a request to invoke GetTrainTask API

type GetTrainTaskResponse 

type GetTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetTrainTaskResponse is the response struct for api GetTrainTask

func CreateGetTrainTaskResponse 

func CreateGetTrainTaskResponse() (response *GetTrainTaskResponse)

CreateGetTrainTaskResponse creates a response to parse from GetTrainTask response

type GetUploadPolicyRequest 

type GetUploadPolicyRequest struct {
	*requests.RpcRequest
	Type     string           `position:"Body" name:"Type"`
	Id       requests.Integer `position:"Body" name:"Id"`
	FileName string           `position:"Body" name:"FileName"`
}

GetUploadPolicyRequest is the request struct for api GetUploadPolicy

func CreateGetUploadPolicyRequest 

func CreateGetUploadPolicyRequest() (request *GetUploadPolicyRequest)

CreateGetUploadPolicyRequest creates a request to invoke GetUploadPolicy API

type GetUploadPolicyResponse 

type GetUploadPolicyResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetUploadPolicyResponse is the response struct for api GetUploadPolicy

func CreateGetUploadPolicyResponse 

func CreateGetUploadPolicyResponse() (response *GetUploadPolicyResponse)

CreateGetUploadPolicyResponse creates a response to parse from GetUploadPolicy response

type GetUserInfoRequest 

type GetUserInfoRequest struct {
	*requests.RpcRequest
}

GetUserInfoRequest is the request struct for api GetUserInfo

func CreateGetUserInfoRequest 

func CreateGetUserInfoRequest() (request *GetUserInfoRequest)

CreateGetUserInfoRequest creates a request to invoke GetUserInfo API

type GetUserInfoResponse 

type GetUserInfoResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetUserInfoResponse is the response struct for api GetUserInfo

func CreateGetUserInfoResponse 

func CreateGetUserInfoResponse() (response *GetUserInfoResponse)

CreateGetUserInfoResponse creates a response to parse from GetUserInfo response

type GetWorkspaceRequest 

type GetWorkspaceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

GetWorkspaceRequest is the request struct for api GetWorkspace

func CreateGetWorkspaceRequest 

func CreateGetWorkspaceRequest() (request *GetWorkspaceRequest)

CreateGetWorkspaceRequest creates a request to invoke GetWorkspace API

type GetWorkspaceResponse 

type GetWorkspaceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetWorkspaceResponse is the response struct for api GetWorkspace

func CreateGetWorkspaceResponse 

func CreateGetWorkspaceResponse() (response *GetWorkspaceResponse)

CreateGetWorkspaceResponse creates a response to parse from GetWorkspace response

type ListDataReflowDatasRequest 

type ListDataReflowDatasRequest struct {
	*requests.RpcRequest
	StartTime   requests.Integer `position:"Body" name:"StartTime"`
	ImageName   string           `position:"Body" name:"ImageName"`
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	EndTime     requests.Integer `position:"Body" name:"EndTime"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	ServiceId   requests.Integer `position:"Body" name:"ServiceId"`
	Category    string           `position:"Body" name:"Category"`
}

ListDataReflowDatasRequest is the request struct for api ListDataReflowDatas

func CreateListDataReflowDatasRequest 

func CreateListDataReflowDatasRequest() (request *ListDataReflowDatasRequest)

CreateListDataReflowDatasRequest creates a request to invoke ListDataReflowDatas API

type ListDataReflowDatasResponse 

type ListDataReflowDatasResponse struct {
	*responses.BaseResponse
	Message   string                    `json:"Message" xml:"Message"`
	RequestId string                    `json:"RequestId" xml:"RequestId"`
	Code      string                    `json:"Code" xml:"Code"`
	Data      DataInListDataReflowDatas `json:"Data" xml:"Data"`
}

ListDataReflowDatasResponse is the response struct for api ListDataReflowDatas

func CreateListDataReflowDatasResponse 

func CreateListDataReflowDatasResponse() (response *ListDataReflowDatasResponse)

CreateListDataReflowDatasResponse creates a response to parse from ListDataReflowDatas response

type ListDatasetDatasRequest 

type ListDatasetDatasRequest struct {
	*requests.RpcRequest
	Identity    string           `position:"Body" name:"Identity"`
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	DatasetId   requests.Integer `position:"Body" name:"DatasetId"`
}

ListDatasetDatasRequest is the request struct for api ListDatasetDatas

func CreateListDatasetDatasRequest 

func CreateListDatasetDatasRequest() (request *ListDatasetDatasRequest)

CreateListDatasetDatasRequest creates a request to invoke ListDatasetDatas API

type ListDatasetDatasResponse 

type ListDatasetDatasResponse struct {
	*responses.BaseResponse
	Message   string                 `json:"Message" xml:"Message"`
	RequestId string                 `json:"RequestId" xml:"RequestId"`
	Code      string                 `json:"Code" xml:"Code"`
	Data      DataInListDatasetDatas `json:"Data" xml:"Data"`
}

ListDatasetDatasResponse is the response struct for api ListDatasetDatas

func CreateListDatasetDatasResponse 

func CreateListDatasetDatasResponse() (response *ListDatasetDatasResponse)

CreateListDatasetDatasResponse creates a response to parse from ListDatasetDatas response

type ListDatasetsRequest 

type ListDatasetsRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	WorkspaceId requests.Integer `position:"Body" name:"WorkspaceId"`
}

ListDatasetsRequest is the request struct for api ListDatasets

func CreateListDatasetsRequest 

func CreateListDatasetsRequest() (request *ListDatasetsRequest)

CreateListDatasetsRequest creates a request to invoke ListDatasets API

type ListDatasetsResponse 

type ListDatasetsResponse struct {
	*responses.BaseResponse
	Message   string             `json:"Message" xml:"Message"`
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Code      string             `json:"Code" xml:"Code"`
	Data      DataInListDatasets `json:"Data" xml:"Data"`
}

ListDatasetsResponse is the response struct for api ListDatasets

func CreateListDatasetsResponse 

func CreateListDatasetsResponse() (response *ListDatasetsResponse)

CreateListDatasetsResponse creates a response to parse from ListDatasets response

type ListLabelsetDatasRequest 

type ListLabelsetDatasRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	Value       string           `position:"Body" name:"Value"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	IsAbandon   requests.Boolean `position:"Body" name:"IsAbandon"`
	LabelId     requests.Integer `position:"Body" name:"LabelId"`
	Name        string           `position:"Body" name:"Name"`
	Operation   string           `position:"Body" name:"Operation"`
}

ListLabelsetDatasRequest is the request struct for api ListLabelsetDatas

func CreateListLabelsetDatasRequest 

func CreateListLabelsetDatasRequest() (request *ListLabelsetDatasRequest)

CreateListLabelsetDatasRequest creates a request to invoke ListLabelsetDatas API

type ListLabelsetDatasResponse 

type ListLabelsetDatasResponse struct {
	*responses.BaseResponse
	Message   string                  `json:"Message" xml:"Message"`
	RequestId string                  `json:"RequestId" xml:"RequestId"`
	Code      string                  `json:"Code" xml:"Code"`
	Data      DataInListLabelsetDatas `json:"Data" xml:"Data"`
}

ListLabelsetDatasResponse is the response struct for api ListLabelsetDatas

func CreateListLabelsetDatasResponse 

func CreateListLabelsetDatasResponse() (response *ListLabelsetDatasResponse)

CreateListLabelsetDatasResponse creates a response to parse from ListLabelsetDatas response

type ListLabelsetsRequest 

type ListLabelsetsRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	DatasetId   requests.Integer `position:"Body" name:"DatasetId"`
	Status      string           `position:"Body" name:"Status"`
}

ListLabelsetsRequest is the request struct for api ListLabelsets

func CreateListLabelsetsRequest 

func CreateListLabelsetsRequest() (request *ListLabelsetsRequest)

CreateListLabelsetsRequest creates a request to invoke ListLabelsets API

type ListLabelsetsResponse 

type ListLabelsetsResponse struct {
	*responses.BaseResponse
	Message   string              `json:"Message" xml:"Message"`
	RequestId string              `json:"RequestId" xml:"RequestId"`
	Code      string              `json:"Code" xml:"Code"`
	Data      DataInListLabelsets `json:"Data" xml:"Data"`
}

ListLabelsetsResponse is the response struct for api ListLabelsets

func CreateListLabelsetsResponse 

func CreateListLabelsetsResponse() (response *ListLabelsetsResponse)

CreateListLabelsetsResponse creates a response to parse from ListLabelsets response

type ListServicesRequest 

type ListServicesRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	Id          requests.Integer `position:"Body" name:"Id"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	Name        requests.Integer `position:"Body" name:"Name"`
	WorkspaceId requests.Integer `position:"Body" name:"WorkspaceId"`
}

ListServicesRequest is the request struct for api ListServices

func CreateListServicesRequest 

func CreateListServicesRequest() (request *ListServicesRequest)

CreateListServicesRequest creates a request to invoke ListServices API

type ListServicesResponse 

type ListServicesResponse struct {
	*responses.BaseResponse
	Message   string             `json:"Message" xml:"Message"`
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Code      string             `json:"Code" xml:"Code"`
	Data      DataInListServices `json:"Data" xml:"Data"`
}

ListServicesResponse is the response struct for api ListServices

func CreateListServicesResponse 

func CreateListServicesResponse() (response *ListServicesResponse)

CreateListServicesResponse creates a response to parse from ListServices response

type ListTrainTasksRequest 

type ListTrainTasksRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	Status      string           `position:"Body" name:"Status"`
	WorkspaceId requests.Integer `position:"Body" name:"WorkspaceId"`
}

ListTrainTasksRequest is the request struct for api ListTrainTasks

func CreateListTrainTasksRequest 

func CreateListTrainTasksRequest() (request *ListTrainTasksRequest)

CreateListTrainTasksRequest creates a request to invoke ListTrainTasks API

type ListTrainTasksResponse 

type ListTrainTasksResponse struct {
	*responses.BaseResponse
	Message   string               `json:"Message" xml:"Message"`
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Code      string               `json:"Code" xml:"Code"`
	Data      DataInListTrainTasks `json:"Data" xml:"Data"`
}

ListTrainTasksResponse is the response struct for api ListTrainTasks

func CreateListTrainTasksResponse 

func CreateListTrainTasksResponse() (response *ListTrainTasksResponse)

CreateListTrainTasksResponse creates a response to parse from ListTrainTasks response

type ListWorkspacesRequest 

type ListWorkspacesRequest struct {
	*requests.RpcRequest
	PageSize    requests.Integer `position:"Body" name:"PageSize"`
	CurrentPage requests.Integer `position:"Body" name:"CurrentPage"`
	Name        string           `position:"Body" name:"Name"`
}

ListWorkspacesRequest is the request struct for api ListWorkspaces

func CreateListWorkspacesRequest 

func CreateListWorkspacesRequest() (request *ListWorkspacesRequest)

CreateListWorkspacesRequest creates a request to invoke ListWorkspaces API

type ListWorkspacesResponse 

type ListWorkspacesResponse struct {
	*responses.BaseResponse
	Message   string               `json:"Message" xml:"Message"`
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Code      string               `json:"Code" xml:"Code"`
	Data      DataInListWorkspaces `json:"Data" xml:"Data"`
}

ListWorkspacesResponse is the response struct for api ListWorkspaces

func CreateListWorkspacesResponse 

func CreateListWorkspacesResponse() (response *ListWorkspacesResponse)

CreateListWorkspacesResponse creates a response to parse from ListWorkspaces response

type Mask 

type Mask struct {
	Counts string `json:"Counts" xml:"Counts"`
	Sizes  []int  `json:"Sizes" xml:"Sizes"`
}

Mask is a nested struct in viapi_regen response

type SetDatasetUserOssPathRequest 

type SetDatasetUserOssPathRequest struct {
	*requests.RpcRequest
	UserOssUrl string           `position:"Body" name:"UserOssUrl"`
	DatasetId  requests.Integer `position:"Body" name:"DatasetId"`
}

SetDatasetUserOssPathRequest is the request struct for api SetDatasetUserOssPath

func CreateSetDatasetUserOssPathRequest 

func CreateSetDatasetUserOssPathRequest() (request *SetDatasetUserOssPathRequest)

CreateSetDatasetUserOssPathRequest creates a request to invoke SetDatasetUserOssPath API

type SetDatasetUserOssPathResponse 

type SetDatasetUserOssPathResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

SetDatasetUserOssPathResponse is the response struct for api SetDatasetUserOssPath

func CreateSetDatasetUserOssPathResponse 

func CreateSetDatasetUserOssPathResponse() (response *SetDatasetUserOssPathResponse)

CreateSetDatasetUserOssPathResponse creates a response to parse from SetDatasetUserOssPath response

type Sizes 

type Sizes struct {
	Sizes []int `json:"sizes" xml:"sizes"`
}

Sizes is a nested struct in viapi_regen response

type StartServiceRequest 

type StartServiceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

StartServiceRequest is the request struct for api StartService

func CreateStartServiceRequest 

func CreateStartServiceRequest() (request *StartServiceRequest)

CreateStartServiceRequest creates a request to invoke StartService API

type StartServiceResponse 

type StartServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

StartServiceResponse is the response struct for api StartService

func CreateStartServiceResponse 

func CreateStartServiceResponse() (response *StartServiceResponse)

CreateStartServiceResponse creates a response to parse from StartService response

type StartTrainTaskRequest 

type StartTrainTaskRequest struct {
	*requests.RpcRequest
	RelyOnTaskId   requests.Integer `position:"Body" name:"RelyOnTaskId"`
	ForceStartFlag requests.Boolean `position:"Body" name:"ForceStartFlag"`
	Id             requests.Integer `position:"Body" name:"Id"`
}

StartTrainTaskRequest is the request struct for api StartTrainTask

func CreateStartTrainTaskRequest 

func CreateStartTrainTaskRequest() (request *StartTrainTaskRequest)

CreateStartTrainTaskRequest creates a request to invoke StartTrainTask API

type StartTrainTaskResponse 

type StartTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

StartTrainTaskResponse is the response struct for api StartTrainTask

func CreateStartTrainTaskResponse 

func CreateStartTrainTaskResponse() (response *StartTrainTaskResponse)

CreateStartTrainTaskResponse creates a response to parse from StartTrainTask response

type StopServiceRequest 

type StopServiceRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

StopServiceRequest is the request struct for api StopService

func CreateStopServiceRequest 

func CreateStopServiceRequest() (request *StopServiceRequest)

CreateStopServiceRequest creates a request to invoke StopService API

type StopServiceResponse 

type StopServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

StopServiceResponse is the response struct for api StopService

func CreateStopServiceResponse 

func CreateStopServiceResponse() (response *StopServiceResponse)

CreateStopServiceResponse creates a response to parse from StopService response

type StopTrainTaskRequest 

type StopTrainTaskRequest struct {
	*requests.RpcRequest
	Id requests.Integer `position:"Body" name:"Id"`
}

StopTrainTaskRequest is the request struct for api StopTrainTask

func CreateStopTrainTaskRequest 

func CreateStopTrainTaskRequest() (request *StopTrainTaskRequest)

CreateStopTrainTaskRequest creates a request to invoke StopTrainTask API

type StopTrainTaskResponse 

type StopTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

StopTrainTaskResponse is the response struct for api StopTrainTask

func CreateStopTrainTaskResponse 

func CreateStopTrainTaskResponse() (response *StopTrainTaskResponse)

CreateStopTrainTaskResponse creates a response to parse from StopTrainTask response

type UpdateDatasetRequest 

type UpdateDatasetRequest struct {
	*requests.RpcRequest
	Description string           `position:"Body" name:"Description"`
	Id          requests.Integer `position:"Body" name:"Id"`
	Name        string           `position:"Body" name:"Name"`
}

UpdateDatasetRequest is the request struct for api UpdateDataset

func CreateUpdateDatasetRequest 

func CreateUpdateDatasetRequest() (request *UpdateDatasetRequest)

CreateUpdateDatasetRequest creates a request to invoke UpdateDataset API

type UpdateDatasetResponse 

type UpdateDatasetResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

UpdateDatasetResponse is the response struct for api UpdateDataset

func CreateUpdateDatasetResponse 

func CreateUpdateDatasetResponse() (response *UpdateDatasetResponse)

CreateUpdateDatasetResponse creates a response to parse from UpdateDataset response

type UpdateLabelsetRequest 

type UpdateLabelsetRequest struct {
	*requests.RpcRequest
	Description string           `position:"Body" name:"Description"`
	Id          requests.Integer `position:"Body" name:"Id"`
	TagUserList string           `position:"Body" name:"TagUserList"`
	UserOssUrl  string           `position:"Body" name:"UserOssUrl"`
	ObjectKey   string           `position:"Body" name:"ObjectKey"`
	Name        string           `position:"Body" name:"Name"`
}

UpdateLabelsetRequest is the request struct for api UpdateLabelset

func CreateUpdateLabelsetRequest 

func CreateUpdateLabelsetRequest() (request *UpdateLabelsetRequest)

CreateUpdateLabelsetRequest creates a request to invoke UpdateLabelset API

type UpdateLabelsetResponse 

type UpdateLabelsetResponse struct {
	*responses.BaseResponse
	Message   string               `json:"Message" xml:"Message"`
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Code      string               `json:"Code" xml:"Code"`
	Data      DataInUpdateLabelset `json:"Data" xml:"Data"`
}

UpdateLabelsetResponse is the response struct for api UpdateLabelset

func CreateUpdateLabelsetResponse 

func CreateUpdateLabelsetResponse() (response *UpdateLabelsetResponse)

CreateUpdateLabelsetResponse creates a response to parse from UpdateLabelset response

type UpdateServiceRequest 

type UpdateServiceRequest struct {
	*requests.RpcRequest
	Description       string           `position:"Body" name:"Description"`
	Id                requests.Integer `position:"Body" name:"Id"`
	AuthorizationType string           `position:"Body" name:"AuthorizationType"`
	Name              string           `position:"Body" name:"Name"`
	AuthorizedAccount string           `position:"Body" name:"AuthorizedAccount"`
}

UpdateServiceRequest is the request struct for api UpdateService

func CreateUpdateServiceRequest 

func CreateUpdateServiceRequest() (request *UpdateServiceRequest)

CreateUpdateServiceRequest creates a request to invoke UpdateService API

type UpdateServiceResponse 

type UpdateServiceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

UpdateServiceResponse is the response struct for api UpdateService

func CreateUpdateServiceResponse 

func CreateUpdateServiceResponse() (response *UpdateServiceResponse)

CreateUpdateServiceResponse creates a response to parse from UpdateService response

type UpdateTrainTaskRequest 

type UpdateTrainTaskRequest struct {
	*requests.RpcRequest
	Description        string           `position:"Body" name:"Description"`
	TrainMode          string           `position:"Body" name:"TrainMode"`
	Id                 requests.Integer `position:"Body" name:"Id"`
	DatasetIds         string           `position:"Body" name:"DatasetIds"`
	PreTrainTaskId     requests.Integer `position:"Body" name:"PreTrainTaskId"`
	PreTrainTaskFlag   requests.Boolean `position:"Body" name:"PreTrainTaskFlag"`
	AdvancedParameters string           `position:"Body" name:"AdvancedParameters"`
	LabelId            requests.Integer `position:"Body" name:"LabelId"`
	Name               string           `position:"Body" name:"Name"`
	DatasetId          requests.Integer `position:"Body" name:"DatasetId"`
	LabelIds           string           `position:"Body" name:"LabelIds"`
}

UpdateTrainTaskRequest is the request struct for api UpdateTrainTask

func CreateUpdateTrainTaskRequest 

func CreateUpdateTrainTaskRequest() (request *UpdateTrainTaskRequest)

CreateUpdateTrainTaskRequest creates a request to invoke UpdateTrainTask API

type UpdateTrainTaskResponse 

type UpdateTrainTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

UpdateTrainTaskResponse is the response struct for api UpdateTrainTask

func CreateUpdateTrainTaskResponse 

func CreateUpdateTrainTaskResponse() (response *UpdateTrainTaskResponse)

CreateUpdateTrainTaskResponse creates a response to parse from UpdateTrainTask response

type UpdateWorkspaceRequest 

type UpdateWorkspaceRequest struct {
	*requests.RpcRequest
	Description string           `position:"Body" name:"Description"`
	Id          requests.Integer `position:"Body" name:"Id"`
	Name        string           `position:"Body" name:"Name"`
}

UpdateWorkspaceRequest is the request struct for api UpdateWorkspace

func CreateUpdateWorkspaceRequest 

func CreateUpdateWorkspaceRequest() (request *UpdateWorkspaceRequest)

CreateUpdateWorkspaceRequest creates a request to invoke UpdateWorkspace API

type UpdateWorkspaceResponse 

type UpdateWorkspaceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Data      Data   `json:"Data" xml:"Data"`
}

UpdateWorkspaceResponse is the response struct for api UpdateWorkspace

func CreateUpdateWorkspaceResponse 

func CreateUpdateWorkspaceResponse() (response *UpdateWorkspaceResponse)

CreateUpdateWorkspaceResponse creates a response to parse from UpdateWorkspace response

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.