qualitycheck

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: 5 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type AddBusinessCategoryRequest ¶

type AddBusinessCategoryRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

AddBusinessCategoryRequest is the request struct for api AddBusinessCategory

func CreateAddBusinessCategoryRequest ¶

func CreateAddBusinessCategoryRequest() (request *AddBusinessCategoryRequest)

CreateAddBusinessCategoryRequest creates a request to invoke AddBusinessCategory API

type AddBusinessCategoryResponse ¶

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

AddBusinessCategoryResponse is the response struct for api AddBusinessCategory

func CreateAddBusinessCategoryResponse ¶

func CreateAddBusinessCategoryResponse() (response *AddBusinessCategoryResponse)

CreateAddBusinessCategoryResponse creates a response to parse from AddBusinessCategory response

type AddRuleCategoryRequest ¶

type AddRuleCategoryRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

AddRuleCategoryRequest is the request struct for api AddRuleCategory

func CreateAddRuleCategoryRequest ¶

func CreateAddRuleCategoryRequest() (request *AddRuleCategoryRequest)

CreateAddRuleCategoryRequest creates a request to invoke AddRuleCategory API

type AddRuleCategoryResponse ¶

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

AddRuleCategoryResponse is the response struct for api AddRuleCategory

func CreateAddRuleCategoryResponse ¶

func CreateAddRuleCategoryResponse() (response *AddRuleCategoryResponse)

CreateAddRuleCategoryResponse creates a response to parse from AddRuleCategory response

type AddThesaurusForApiRequest ¶

type AddThesaurusForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

AddThesaurusForApiRequest is the request struct for api AddThesaurusForApi

func CreateAddThesaurusForApiRequest ¶

func CreateAddThesaurusForApiRequest() (request *AddThesaurusForApiRequest)

CreateAddThesaurusForApiRequest creates a request to invoke AddThesaurusForApi API

type AddThesaurusForApiResponse ¶

type AddThesaurusForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      int64  `json:"Data" xml:"Data"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

AddThesaurusForApiResponse is the response struct for api AddThesaurusForApi

func CreateAddThesaurusForApiResponse ¶

func CreateAddThesaurusForApiResponse() (response *AddThesaurusForApiResponse)

CreateAddThesaurusForApiResponse creates a response to parse from AddThesaurusForApi response

type Agent ¶

type Agent struct {
	Name       string `json:"Name" xml:"Name"`
	AgentName  string `json:"AgentName" xml:"AgentName"`
	AgentId    string `json:"AgentId" xml:"AgentId"`
	SkillGroup string `json:"SkillGroup" xml:"SkillGroup"`
	Id         string `json:"Id" xml:"Id"`
}

Agent is a nested struct in qualitycheck response

type Agents ¶

type Agents struct {
	Agent []Agent `json:"Agent" xml:"Agent"`
}

Agents is a nested struct in qualitycheck response

type AllRuleListInGetSkillGroupConfig ¶

type AllRuleListInGetSkillGroupConfig struct {
	RuleNameInfo []RuleNameInfo `json:"RuleNameInfo" xml:"RuleNameInfo"`
}

AllRuleListInGetSkillGroupConfig is a nested struct in qualitycheck response

type AllRuleListInListSkillGroupConfig ¶

type AllRuleListInListSkillGroupConfig struct {
	RuleNameInfo []RuleNameInfo `json:"RuleNameInfo" xml:"RuleNameInfo"`
}

AllRuleListInListSkillGroupConfig is a nested struct in qualitycheck response

type Anchor ¶

type Anchor struct {
	HitTime   int    `json:"HitTime" xml:"HitTime"`
	Location  string `json:"Location" xml:"Location"`
	AnchorCid string `json:"AnchorCid" xml:"AnchorCid"`
}

Anchor is a nested struct in qualitycheck response

type AntModelInfo ¶

type AntModelInfo struct {
	AntModelInfo []string `json:"AntModelInfo" xml:"AntModelInfo"`
}

AntModelInfo is a nested struct in qualitycheck response

type AsrResultInGetResult ¶

type AsrResultInGetResult struct {
	AsrResultItem []AsrResultItem `json:"AsrResult" xml:"AsrResult"`
}

AsrResultInGetResult is a nested struct in qualitycheck response

type AsrResultInGetSyncResult ¶

type AsrResultInGetSyncResult struct {
	AsrResultItem []AsrResultItem `json:"AsrResult" xml:"AsrResult"`
}

AsrResultInGetSyncResult is a nested struct in qualitycheck response

type AsrResultItem ¶

type AsrResultItem struct {
	End             int64  `json:"End" xml:"End"`
	Words           string `json:"Words" xml:"Words"`
	Role            string `json:"Role" xml:"Role"`
	SpeechRate      int    `json:"SpeechRate" xml:"SpeechRate"`
	SilenceDuration int    `json:"SilenceDuration" xml:"SilenceDuration"`
	Begin           int64  `json:"Begin" xml:"Begin"`
	EmotionValue    int    `json:"EmotionValue" xml:"EmotionValue"`
}

AsrResultItem is a nested struct in qualitycheck response

type AsrVocab ¶

type AsrVocab struct {
	VocabularyId string `json:"VocabularyId" xml:"VocabularyId"`
	UpdateTime   string `json:"UpdateTime" xml:"UpdateTime"`
	Name         string `json:"Name" xml:"Name"`
	CreateTime   string `json:"CreateTime" xml:"CreateTime"`
	Id           string `json:"Id" xml:"Id"`
}

AsrVocab is a nested struct in qualitycheck response

type AssignReviewerRequest ¶

type AssignReviewerRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

AssignReviewerRequest is the request struct for api AssignReviewer

func CreateAssignReviewerRequest ¶

func CreateAssignReviewerRequest() (request *AssignReviewerRequest)

CreateAssignReviewerRequest creates a request to invoke AssignReviewer API

type AssignReviewerResponse ¶

type AssignReviewerResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

AssignReviewerResponse is the response struct for api AssignReviewer

func CreateAssignReviewerResponse ¶

func CreateAssignReviewerResponse() (response *AssignReviewerResponse)

CreateAssignReviewerResponse creates a response to parse from AssignReviewer response

type BusinessCategories ¶

type BusinessCategories struct {
	BusinessCategoryBasicInfo []BusinessCategoryBasicInfo `json:"BusinessCategoryBasicInfo" xml:"BusinessCategoryBasicInfo"`
}

BusinessCategories is a nested struct in qualitycheck response

type BusinessCategoryBasicInfo ¶

type BusinessCategoryBasicInfo struct {
	BusinessName string `json:"BusinessName" xml:"BusinessName"`
	Bid          int    `json:"Bid" xml:"Bid"`
	ServiceType  int    `json:"ServiceType" xml:"ServiceType"`
}

BusinessCategoryBasicInfo is a nested struct in qualitycheck response

type BusinessCategoryNameListInGetRule ¶

type BusinessCategoryNameListInGetRule struct {
	BusinessCategoryNameList []string `json:"BusinessCategoryNameList" xml:"BusinessCategoryNameList"`
}

BusinessCategoryNameListInGetRule is a nested struct in qualitycheck response

type BusinessCategoryNameListInListRules ¶

type BusinessCategoryNameListInListRules struct {
	BusinessCategoryNameList []string `json:"BusinessCategoryNameList" xml:"BusinessCategoryNameList"`
}

BusinessCategoryNameListInListRules is a nested struct in qualitycheck response

type Channel ¶

type Channel struct {
	Type int    `json:"Type" xml:"Type"`
	Url  string `json:"Url" xml:"Url"`
}

Channel is a nested struct in qualitycheck response

type Channels ¶

type Channels struct {
	Channel []Channel `json:"Channel" xml:"Channel"`
}

Channels is a nested struct in qualitycheck response

type CheckRange ¶

type CheckRange struct {
	Absolute bool   `json:"Absolute" xml:"Absolute"`
	Role     string `json:"Role" xml:"Role"`
	Anchor   Anchor `json:"Anchor" xml:"Anchor"`
	Range    Range  `json:"Range" xml:"Range"`
}

CheckRange is a nested struct in qualitycheck response

type CidInGetResult ¶

type CidInGetResult struct {
	Cid []string `json:"Cid" xml:"Cid"`
}

CidInGetResult is a nested struct in qualitycheck response

type CidInGetResultToReview ¶

type CidInGetResultToReview struct {
	Cid []string `json:"Cid" xml:"Cid"`
}

CidInGetResultToReview is a nested struct in qualitycheck response

type CidInGetSyncResult ¶

type CidInGetSyncResult struct {
	Cid []string `json:"Cid" xml:"Cid"`
}

CidInGetSyncResult is a nested struct in qualitycheck 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) AddBusinessCategory ¶

func (client *Client) AddBusinessCategory(request *AddBusinessCategoryRequest) (response *AddBusinessCategoryResponse, err error)

AddBusinessCategory invokes the qualitycheck.AddBusinessCategory API synchronously

func (*Client) AddBusinessCategoryWithCallback ¶

func (client *Client) AddBusinessCategoryWithCallback(request *AddBusinessCategoryRequest, callback func(response *AddBusinessCategoryResponse, err error)) <-chan int

AddBusinessCategoryWithCallback invokes the qualitycheck.AddBusinessCategory API asynchronously

func (*Client) AddBusinessCategoryWithChan ¶

func (client *Client) AddBusinessCategoryWithChan(request *AddBusinessCategoryRequest) (<-chan *AddBusinessCategoryResponse, <-chan error)

AddBusinessCategoryWithChan invokes the qualitycheck.AddBusinessCategory API asynchronously

func (*Client) AddRuleCategory ¶

func (client *Client) AddRuleCategory(request *AddRuleCategoryRequest) (response *AddRuleCategoryResponse, err error)

AddRuleCategory invokes the qualitycheck.AddRuleCategory API synchronously

func (*Client) AddRuleCategoryWithCallback ¶

func (client *Client) AddRuleCategoryWithCallback(request *AddRuleCategoryRequest, callback func(response *AddRuleCategoryResponse, err error)) <-chan int

AddRuleCategoryWithCallback invokes the qualitycheck.AddRuleCategory API asynchronously

func (*Client) AddRuleCategoryWithChan ¶

func (client *Client) AddRuleCategoryWithChan(request *AddRuleCategoryRequest) (<-chan *AddRuleCategoryResponse, <-chan error)

AddRuleCategoryWithChan invokes the qualitycheck.AddRuleCategory API asynchronously

func (*Client) AddThesaurusForApi ¶

func (client *Client) AddThesaurusForApi(request *AddThesaurusForApiRequest) (response *AddThesaurusForApiResponse, err error)

AddThesaurusForApi invokes the qualitycheck.AddThesaurusForApi API synchronously

func (*Client) AddThesaurusForApiWithCallback ¶

func (client *Client) AddThesaurusForApiWithCallback(request *AddThesaurusForApiRequest, callback func(response *AddThesaurusForApiResponse, err error)) <-chan int

AddThesaurusForApiWithCallback invokes the qualitycheck.AddThesaurusForApi API asynchronously

func (*Client) AddThesaurusForApiWithChan ¶

func (client *Client) AddThesaurusForApiWithChan(request *AddThesaurusForApiRequest) (<-chan *AddThesaurusForApiResponse, <-chan error)

AddThesaurusForApiWithChan invokes the qualitycheck.AddThesaurusForApi API asynchronously

func (*Client) AssignReviewer ¶

func (client *Client) AssignReviewer(request *AssignReviewerRequest) (response *AssignReviewerResponse, err error)

AssignReviewer invokes the qualitycheck.AssignReviewer API synchronously

func (*Client) AssignReviewerWithCallback ¶

func (client *Client) AssignReviewerWithCallback(request *AssignReviewerRequest, callback func(response *AssignReviewerResponse, err error)) <-chan int

AssignReviewerWithCallback invokes the qualitycheck.AssignReviewer API asynchronously

func (*Client) AssignReviewerWithChan ¶

func (client *Client) AssignReviewerWithChan(request *AssignReviewerRequest) (<-chan *AssignReviewerResponse, <-chan error)

AssignReviewerWithChan invokes the qualitycheck.AssignReviewer API asynchronously

func (*Client) CreateAsrVocab ¶

func (client *Client) CreateAsrVocab(request *CreateAsrVocabRequest) (response *CreateAsrVocabResponse, err error)

CreateAsrVocab invokes the qualitycheck.CreateAsrVocab API synchronously

func (*Client) CreateAsrVocabWithCallback ¶

func (client *Client) CreateAsrVocabWithCallback(request *CreateAsrVocabRequest, callback func(response *CreateAsrVocabResponse, err error)) <-chan int

CreateAsrVocabWithCallback invokes the qualitycheck.CreateAsrVocab API asynchronously

func (*Client) CreateAsrVocabWithChan ¶

func (client *Client) CreateAsrVocabWithChan(request *CreateAsrVocabRequest) (<-chan *CreateAsrVocabResponse, <-chan error)

CreateAsrVocabWithChan invokes the qualitycheck.CreateAsrVocab API asynchronously

func (*Client) CreateSkillGroupConfig ¶

func (client *Client) CreateSkillGroupConfig(request *CreateSkillGroupConfigRequest) (response *CreateSkillGroupConfigResponse, err error)

CreateSkillGroupConfig invokes the qualitycheck.CreateSkillGroupConfig API synchronously

func (*Client) CreateSkillGroupConfigWithCallback ¶

func (client *Client) CreateSkillGroupConfigWithCallback(request *CreateSkillGroupConfigRequest, callback func(response *CreateSkillGroupConfigResponse, err error)) <-chan int

CreateSkillGroupConfigWithCallback invokes the qualitycheck.CreateSkillGroupConfig API asynchronously

func (*Client) CreateSkillGroupConfigWithChan ¶

func (client *Client) CreateSkillGroupConfigWithChan(request *CreateSkillGroupConfigRequest) (<-chan *CreateSkillGroupConfigResponse, <-chan error)

CreateSkillGroupConfigWithChan invokes the qualitycheck.CreateSkillGroupConfig API asynchronously

func (*Client) CreateTaskAssignRule ¶

func (client *Client) CreateTaskAssignRule(request *CreateTaskAssignRuleRequest) (response *CreateTaskAssignRuleResponse, err error)

CreateTaskAssignRule invokes the qualitycheck.CreateTaskAssignRule API synchronously

func (*Client) CreateTaskAssignRuleWithCallback ¶

func (client *Client) CreateTaskAssignRuleWithCallback(request *CreateTaskAssignRuleRequest, callback func(response *CreateTaskAssignRuleResponse, err error)) <-chan int

CreateTaskAssignRuleWithCallback invokes the qualitycheck.CreateTaskAssignRule API asynchronously

func (*Client) CreateTaskAssignRuleWithChan ¶

func (client *Client) CreateTaskAssignRuleWithChan(request *CreateTaskAssignRuleRequest) (<-chan *CreateTaskAssignRuleResponse, <-chan error)

CreateTaskAssignRuleWithChan invokes the qualitycheck.CreateTaskAssignRule API asynchronously

func (*Client) CreateUser ¶

func (client *Client) CreateUser(request *CreateUserRequest) (response *CreateUserResponse, err error)

CreateUser invokes the qualitycheck.CreateUser API synchronously

func (*Client) CreateUserWithCallback ¶

func (client *Client) CreateUserWithCallback(request *CreateUserRequest, callback func(response *CreateUserResponse, err error)) <-chan int

CreateUserWithCallback invokes the qualitycheck.CreateUser API asynchronously

func (*Client) CreateUserWithChan ¶

func (client *Client) CreateUserWithChan(request *CreateUserRequest) (<-chan *CreateUserResponse, <-chan error)

CreateUserWithChan invokes the qualitycheck.CreateUser API asynchronously

func (*Client) CreateWarningConfig ¶

func (client *Client) CreateWarningConfig(request *CreateWarningConfigRequest) (response *CreateWarningConfigResponse, err error)

CreateWarningConfig invokes the qualitycheck.CreateWarningConfig API synchronously

func (*Client) CreateWarningConfigWithCallback ¶

func (client *Client) CreateWarningConfigWithCallback(request *CreateWarningConfigRequest, callback func(response *CreateWarningConfigResponse, err error)) <-chan int

CreateWarningConfigWithCallback invokes the qualitycheck.CreateWarningConfig API asynchronously

func (*Client) CreateWarningConfigWithChan ¶

func (client *Client) CreateWarningConfigWithChan(request *CreateWarningConfigRequest) (<-chan *CreateWarningConfigResponse, <-chan error)

CreateWarningConfigWithChan invokes the qualitycheck.CreateWarningConfig API asynchronously

func (*Client) DelRuleCategory ¶

func (client *Client) DelRuleCategory(request *DelRuleCategoryRequest) (response *DelRuleCategoryResponse, err error)

DelRuleCategory invokes the qualitycheck.DelRuleCategory API synchronously

func (*Client) DelRuleCategoryWithCallback ¶

func (client *Client) DelRuleCategoryWithCallback(request *DelRuleCategoryRequest, callback func(response *DelRuleCategoryResponse, err error)) <-chan int

DelRuleCategoryWithCallback invokes the qualitycheck.DelRuleCategory API asynchronously

func (*Client) DelRuleCategoryWithChan ¶

func (client *Client) DelRuleCategoryWithChan(request *DelRuleCategoryRequest) (<-chan *DelRuleCategoryResponse, <-chan error)

DelRuleCategoryWithChan invokes the qualitycheck.DelRuleCategory API asynchronously

func (*Client) DelThesaurusForApi ¶

func (client *Client) DelThesaurusForApi(request *DelThesaurusForApiRequest) (response *DelThesaurusForApiResponse, err error)

DelThesaurusForApi invokes the qualitycheck.DelThesaurusForApi API synchronously

func (*Client) DelThesaurusForApiWithCallback ¶

func (client *Client) DelThesaurusForApiWithCallback(request *DelThesaurusForApiRequest, callback func(response *DelThesaurusForApiResponse, err error)) <-chan int

DelThesaurusForApiWithCallback invokes the qualitycheck.DelThesaurusForApi API asynchronously

func (*Client) DelThesaurusForApiWithChan ¶

func (client *Client) DelThesaurusForApiWithChan(request *DelThesaurusForApiRequest) (<-chan *DelThesaurusForApiResponse, <-chan error)

DelThesaurusForApiWithChan invokes the qualitycheck.DelThesaurusForApi API asynchronously

func (*Client) DeleteAsrVocab ¶

func (client *Client) DeleteAsrVocab(request *DeleteAsrVocabRequest) (response *DeleteAsrVocabResponse, err error)

DeleteAsrVocab invokes the qualitycheck.DeleteAsrVocab API synchronously

func (*Client) DeleteAsrVocabWithCallback ¶

func (client *Client) DeleteAsrVocabWithCallback(request *DeleteAsrVocabRequest, callback func(response *DeleteAsrVocabResponse, err error)) <-chan int

DeleteAsrVocabWithCallback invokes the qualitycheck.DeleteAsrVocab API asynchronously

func (*Client) DeleteAsrVocabWithChan ¶

func (client *Client) DeleteAsrVocabWithChan(request *DeleteAsrVocabRequest) (<-chan *DeleteAsrVocabResponse, <-chan error)

DeleteAsrVocabWithChan invokes the qualitycheck.DeleteAsrVocab API asynchronously

func (*Client) DeleteBusinessCategory ¶

func (client *Client) DeleteBusinessCategory(request *DeleteBusinessCategoryRequest) (response *DeleteBusinessCategoryResponse, err error)

DeleteBusinessCategory invokes the qualitycheck.DeleteBusinessCategory API synchronously

func (*Client) DeleteBusinessCategoryWithCallback ¶

func (client *Client) DeleteBusinessCategoryWithCallback(request *DeleteBusinessCategoryRequest, callback func(response *DeleteBusinessCategoryResponse, err error)) <-chan int

DeleteBusinessCategoryWithCallback invokes the qualitycheck.DeleteBusinessCategory API asynchronously

func (*Client) DeleteBusinessCategoryWithChan ¶

func (client *Client) DeleteBusinessCategoryWithChan(request *DeleteBusinessCategoryRequest) (<-chan *DeleteBusinessCategoryResponse, <-chan error)

DeleteBusinessCategoryWithChan invokes the qualitycheck.DeleteBusinessCategory API asynchronously

func (*Client) DeleteCustomizationConfig ¶

func (client *Client) DeleteCustomizationConfig(request *DeleteCustomizationConfigRequest) (response *DeleteCustomizationConfigResponse, err error)

DeleteCustomizationConfig invokes the qualitycheck.DeleteCustomizationConfig API synchronously

func (*Client) DeleteCustomizationConfigWithCallback ¶

func (client *Client) DeleteCustomizationConfigWithCallback(request *DeleteCustomizationConfigRequest, callback func(response *DeleteCustomizationConfigResponse, err error)) <-chan int

DeleteCustomizationConfigWithCallback invokes the qualitycheck.DeleteCustomizationConfig API asynchronously

func (*Client) DeleteCustomizationConfigWithChan ¶

func (client *Client) DeleteCustomizationConfigWithChan(request *DeleteCustomizationConfigRequest) (<-chan *DeleteCustomizationConfigResponse, <-chan error)

DeleteCustomizationConfigWithChan invokes the qualitycheck.DeleteCustomizationConfig API asynchronously

func (*Client) DeleteDataSet ¶

func (client *Client) DeleteDataSet(request *DeleteDataSetRequest) (response *DeleteDataSetResponse, err error)

DeleteDataSet invokes the qualitycheck.DeleteDataSet API synchronously

func (*Client) DeleteDataSetWithCallback ¶

func (client *Client) DeleteDataSetWithCallback(request *DeleteDataSetRequest, callback func(response *DeleteDataSetResponse, err error)) <-chan int

DeleteDataSetWithCallback invokes the qualitycheck.DeleteDataSet API asynchronously

func (*Client) DeleteDataSetWithChan ¶

func (client *Client) DeleteDataSetWithChan(request *DeleteDataSetRequest) (<-chan *DeleteDataSetResponse, <-chan error)

DeleteDataSetWithChan invokes the qualitycheck.DeleteDataSet API asynchronously

func (*Client) DeletePrecisionTask ¶

func (client *Client) DeletePrecisionTask(request *DeletePrecisionTaskRequest) (response *DeletePrecisionTaskResponse, err error)

DeletePrecisionTask invokes the qualitycheck.DeletePrecisionTask API synchronously

func (*Client) DeletePrecisionTaskWithCallback ¶

func (client *Client) DeletePrecisionTaskWithCallback(request *DeletePrecisionTaskRequest, callback func(response *DeletePrecisionTaskResponse, err error)) <-chan int

DeletePrecisionTaskWithCallback invokes the qualitycheck.DeletePrecisionTask API asynchronously

func (*Client) DeletePrecisionTaskWithChan ¶

func (client *Client) DeletePrecisionTaskWithChan(request *DeletePrecisionTaskRequest) (<-chan *DeletePrecisionTaskResponse, <-chan error)

DeletePrecisionTaskWithChan invokes the qualitycheck.DeletePrecisionTask API asynchronously

func (*Client) DeleteScoreForApi ¶

func (client *Client) DeleteScoreForApi(request *DeleteScoreForApiRequest) (response *DeleteScoreForApiResponse, err error)

DeleteScoreForApi invokes the qualitycheck.DeleteScoreForApi API synchronously

func (*Client) DeleteScoreForApiWithCallback ¶

func (client *Client) DeleteScoreForApiWithCallback(request *DeleteScoreForApiRequest, callback func(response *DeleteScoreForApiResponse, err error)) <-chan int

DeleteScoreForApiWithCallback invokes the qualitycheck.DeleteScoreForApi API asynchronously

func (*Client) DeleteScoreForApiWithChan ¶

func (client *Client) DeleteScoreForApiWithChan(request *DeleteScoreForApiRequest) (<-chan *DeleteScoreForApiResponse, <-chan error)

DeleteScoreForApiWithChan invokes the qualitycheck.DeleteScoreForApi API asynchronously

func (*Client) DeleteSkillGroupConfig ¶

func (client *Client) DeleteSkillGroupConfig(request *DeleteSkillGroupConfigRequest) (response *DeleteSkillGroupConfigResponse, err error)

DeleteSkillGroupConfig invokes the qualitycheck.DeleteSkillGroupConfig API synchronously

func (*Client) DeleteSkillGroupConfigWithCallback ¶

func (client *Client) DeleteSkillGroupConfigWithCallback(request *DeleteSkillGroupConfigRequest, callback func(response *DeleteSkillGroupConfigResponse, err error)) <-chan int

DeleteSkillGroupConfigWithCallback invokes the qualitycheck.DeleteSkillGroupConfig API asynchronously

func (*Client) DeleteSkillGroupConfigWithChan ¶

func (client *Client) DeleteSkillGroupConfigWithChan(request *DeleteSkillGroupConfigRequest) (<-chan *DeleteSkillGroupConfigResponse, <-chan error)

DeleteSkillGroupConfigWithChan invokes the qualitycheck.DeleteSkillGroupConfig API asynchronously

func (*Client) DeleteSubScoreForApi ¶

func (client *Client) DeleteSubScoreForApi(request *DeleteSubScoreForApiRequest) (response *DeleteSubScoreForApiResponse, err error)

DeleteSubScoreForApi invokes the qualitycheck.DeleteSubScoreForApi API synchronously

func (*Client) DeleteSubScoreForApiWithCallback ¶

func (client *Client) DeleteSubScoreForApiWithCallback(request *DeleteSubScoreForApiRequest, callback func(response *DeleteSubScoreForApiResponse, err error)) <-chan int

DeleteSubScoreForApiWithCallback invokes the qualitycheck.DeleteSubScoreForApi API asynchronously

func (*Client) DeleteSubScoreForApiWithChan ¶

func (client *Client) DeleteSubScoreForApiWithChan(request *DeleteSubScoreForApiRequest) (<-chan *DeleteSubScoreForApiResponse, <-chan error)

DeleteSubScoreForApiWithChan invokes the qualitycheck.DeleteSubScoreForApi API asynchronously

func (*Client) DeleteTaskAssignRule ¶

func (client *Client) DeleteTaskAssignRule(request *DeleteTaskAssignRuleRequest) (response *DeleteTaskAssignRuleResponse, err error)

DeleteTaskAssignRule invokes the qualitycheck.DeleteTaskAssignRule API synchronously

func (*Client) DeleteTaskAssignRuleWithCallback ¶

func (client *Client) DeleteTaskAssignRuleWithCallback(request *DeleteTaskAssignRuleRequest, callback func(response *DeleteTaskAssignRuleResponse, err error)) <-chan int

DeleteTaskAssignRuleWithCallback invokes the qualitycheck.DeleteTaskAssignRule API asynchronously

func (*Client) DeleteTaskAssignRuleWithChan ¶

func (client *Client) DeleteTaskAssignRuleWithChan(request *DeleteTaskAssignRuleRequest) (<-chan *DeleteTaskAssignRuleResponse, <-chan error)

DeleteTaskAssignRuleWithChan invokes the qualitycheck.DeleteTaskAssignRule API asynchronously

func (*Client) DeleteUser ¶

func (client *Client) DeleteUser(request *DeleteUserRequest) (response *DeleteUserResponse, err error)

DeleteUser invokes the qualitycheck.DeleteUser API synchronously

func (*Client) DeleteUserWithCallback ¶

func (client *Client) DeleteUserWithCallback(request *DeleteUserRequest, callback func(response *DeleteUserResponse, err error)) <-chan int

DeleteUserWithCallback invokes the qualitycheck.DeleteUser API asynchronously

func (*Client) DeleteUserWithChan ¶

func (client *Client) DeleteUserWithChan(request *DeleteUserRequest) (<-chan *DeleteUserResponse, <-chan error)

DeleteUserWithChan invokes the qualitycheck.DeleteUser API asynchronously

func (*Client) DeleteWarningConfig ¶

func (client *Client) DeleteWarningConfig(request *DeleteWarningConfigRequest) (response *DeleteWarningConfigResponse, err error)

DeleteWarningConfig invokes the qualitycheck.DeleteWarningConfig API synchronously

func (*Client) DeleteWarningConfigWithCallback ¶

func (client *Client) DeleteWarningConfigWithCallback(request *DeleteWarningConfigRequest, callback func(response *DeleteWarningConfigResponse, err error)) <-chan int

DeleteWarningConfigWithCallback invokes the qualitycheck.DeleteWarningConfig API asynchronously

func (*Client) DeleteWarningConfigWithChan ¶

func (client *Client) DeleteWarningConfigWithChan(request *DeleteWarningConfigRequest) (<-chan *DeleteWarningConfigResponse, <-chan error)

DeleteWarningConfigWithChan invokes the qualitycheck.DeleteWarningConfig API asynchronously

func (*Client) EditThesaurusForApi ¶

func (client *Client) EditThesaurusForApi(request *EditThesaurusForApiRequest) (response *EditThesaurusForApiResponse, err error)

EditThesaurusForApi invokes the qualitycheck.EditThesaurusForApi API synchronously

func (*Client) EditThesaurusForApiWithCallback ¶

func (client *Client) EditThesaurusForApiWithCallback(request *EditThesaurusForApiRequest, callback func(response *EditThesaurusForApiResponse, err error)) <-chan int

EditThesaurusForApiWithCallback invokes the qualitycheck.EditThesaurusForApi API asynchronously

func (*Client) EditThesaurusForApiWithChan ¶

func (client *Client) EditThesaurusForApiWithChan(request *EditThesaurusForApiRequest) (<-chan *EditThesaurusForApiResponse, <-chan error)

EditThesaurusForApiWithChan invokes the qualitycheck.EditThesaurusForApi API asynchronously

func (*Client) GetAsrVocab ¶

func (client *Client) GetAsrVocab(request *GetAsrVocabRequest) (response *GetAsrVocabResponse, err error)

GetAsrVocab invokes the qualitycheck.GetAsrVocab API synchronously

func (*Client) GetAsrVocabWithCallback ¶

func (client *Client) GetAsrVocabWithCallback(request *GetAsrVocabRequest, callback func(response *GetAsrVocabResponse, err error)) <-chan int

GetAsrVocabWithCallback invokes the qualitycheck.GetAsrVocab API asynchronously

func (*Client) GetAsrVocabWithChan ¶

func (client *Client) GetAsrVocabWithChan(request *GetAsrVocabRequest) (<-chan *GetAsrVocabResponse, <-chan error)

GetAsrVocabWithChan invokes the qualitycheck.GetAsrVocab API asynchronously

func (*Client) GetBusinessCategoryList ¶

func (client *Client) GetBusinessCategoryList(request *GetBusinessCategoryListRequest) (response *GetBusinessCategoryListResponse, err error)

GetBusinessCategoryList invokes the qualitycheck.GetBusinessCategoryList API synchronously

func (*Client) GetBusinessCategoryListWithCallback ¶

func (client *Client) GetBusinessCategoryListWithCallback(request *GetBusinessCategoryListRequest, callback func(response *GetBusinessCategoryListResponse, err error)) <-chan int

GetBusinessCategoryListWithCallback invokes the qualitycheck.GetBusinessCategoryList API asynchronously

func (*Client) GetBusinessCategoryListWithChan ¶

func (client *Client) GetBusinessCategoryListWithChan(request *GetBusinessCategoryListRequest) (<-chan *GetBusinessCategoryListResponse, <-chan error)

GetBusinessCategoryListWithChan invokes the qualitycheck.GetBusinessCategoryList API asynchronously

func (*Client) GetCustomizationConfigList ¶

func (client *Client) GetCustomizationConfigList(request *GetCustomizationConfigListRequest) (response *GetCustomizationConfigListResponse, err error)

GetCustomizationConfigList invokes the qualitycheck.GetCustomizationConfigList API synchronously

func (*Client) GetCustomizationConfigListWithCallback ¶

func (client *Client) GetCustomizationConfigListWithCallback(request *GetCustomizationConfigListRequest, callback func(response *GetCustomizationConfigListResponse, err error)) <-chan int

GetCustomizationConfigListWithCallback invokes the qualitycheck.GetCustomizationConfigList API asynchronously

func (*Client) GetCustomizationConfigListWithChan ¶

func (client *Client) GetCustomizationConfigListWithChan(request *GetCustomizationConfigListRequest) (<-chan *GetCustomizationConfigListResponse, <-chan error)

GetCustomizationConfigListWithChan invokes the qualitycheck.GetCustomizationConfigList API asynchronously

func (*Client) GetHitResult ¶

func (client *Client) GetHitResult(request *GetHitResultRequest) (response *GetHitResultResponse, err error)

GetHitResult invokes the qualitycheck.GetHitResult API synchronously

func (*Client) GetHitResultWithCallback ¶

func (client *Client) GetHitResultWithCallback(request *GetHitResultRequest, callback func(response *GetHitResultResponse, err error)) <-chan int

GetHitResultWithCallback invokes the qualitycheck.GetHitResult API asynchronously

func (*Client) GetHitResultWithChan ¶

func (client *Client) GetHitResultWithChan(request *GetHitResultRequest) (<-chan *GetHitResultResponse, <-chan error)

GetHitResultWithChan invokes the qualitycheck.GetHitResult API asynchronously

func (*Client) GetNextResultToVerify ¶

func (client *Client) GetNextResultToVerify(request *GetNextResultToVerifyRequest) (response *GetNextResultToVerifyResponse, err error)

GetNextResultToVerify invokes the qualitycheck.GetNextResultToVerify API synchronously

func (*Client) GetNextResultToVerifyWithCallback ¶

func (client *Client) GetNextResultToVerifyWithCallback(request *GetNextResultToVerifyRequest, callback func(response *GetNextResultToVerifyResponse, err error)) <-chan int

GetNextResultToVerifyWithCallback invokes the qualitycheck.GetNextResultToVerify API asynchronously

func (*Client) GetNextResultToVerifyWithChan ¶

func (client *Client) GetNextResultToVerifyWithChan(request *GetNextResultToVerifyRequest) (<-chan *GetNextResultToVerifyResponse, <-chan error)

GetNextResultToVerifyWithChan invokes the qualitycheck.GetNextResultToVerify API asynchronously

func (*Client) GetPrecisionTask ¶

func (client *Client) GetPrecisionTask(request *GetPrecisionTaskRequest) (response *GetPrecisionTaskResponse, err error)

GetPrecisionTask invokes the qualitycheck.GetPrecisionTask API synchronously

func (*Client) GetPrecisionTaskWithCallback ¶

func (client *Client) GetPrecisionTaskWithCallback(request *GetPrecisionTaskRequest, callback func(response *GetPrecisionTaskResponse, err error)) <-chan int

GetPrecisionTaskWithCallback invokes the qualitycheck.GetPrecisionTask API asynchronously

func (*Client) GetPrecisionTaskWithChan ¶

func (client *Client) GetPrecisionTaskWithChan(request *GetPrecisionTaskRequest) (<-chan *GetPrecisionTaskResponse, <-chan error)

GetPrecisionTaskWithChan invokes the qualitycheck.GetPrecisionTask API asynchronously

func (*Client) GetResult ¶

func (client *Client) GetResult(request *GetResultRequest) (response *GetResultResponse, err error)

GetResult invokes the qualitycheck.GetResult API synchronously

func (*Client) GetResultCallback ¶

func (client *Client) GetResultCallback(request *GetResultCallbackRequest) (response *GetResultCallbackResponse, err error)

GetResultCallback invokes the qualitycheck.GetResultCallback API synchronously

func (*Client) GetResultCallbackWithCallback ¶

func (client *Client) GetResultCallbackWithCallback(request *GetResultCallbackRequest, callback func(response *GetResultCallbackResponse, err error)) <-chan int

GetResultCallbackWithCallback invokes the qualitycheck.GetResultCallback API asynchronously

func (*Client) GetResultCallbackWithChan ¶

func (client *Client) GetResultCallbackWithChan(request *GetResultCallbackRequest) (<-chan *GetResultCallbackResponse, <-chan error)

GetResultCallbackWithChan invokes the qualitycheck.GetResultCallback API asynchronously

func (*Client) GetResultToReview ¶

func (client *Client) GetResultToReview(request *GetResultToReviewRequest) (response *GetResultToReviewResponse, err error)

GetResultToReview invokes the qualitycheck.GetResultToReview API synchronously

func (*Client) GetResultToReviewWithCallback ¶

func (client *Client) GetResultToReviewWithCallback(request *GetResultToReviewRequest, callback func(response *GetResultToReviewResponse, err error)) <-chan int

GetResultToReviewWithCallback invokes the qualitycheck.GetResultToReview API asynchronously

func (*Client) GetResultToReviewWithChan ¶

func (client *Client) GetResultToReviewWithChan(request *GetResultToReviewRequest) (<-chan *GetResultToReviewResponse, <-chan error)

GetResultToReviewWithChan invokes the qualitycheck.GetResultToReview API asynchronously

func (*Client) GetResultWithCallback ¶

func (client *Client) GetResultWithCallback(request *GetResultRequest, callback func(response *GetResultResponse, err error)) <-chan int

GetResultWithCallback invokes the qualitycheck.GetResult API asynchronously

func (*Client) GetResultWithChan ¶

func (client *Client) GetResultWithChan(request *GetResultRequest) (<-chan *GetResultResponse, <-chan error)

GetResultWithChan invokes the qualitycheck.GetResult API asynchronously

func (*Client) GetRule ¶

func (client *Client) GetRule(request *GetRuleRequest) (response *GetRuleResponse, err error)

GetRule invokes the qualitycheck.GetRule API synchronously

func (*Client) GetRuleCategory ¶

func (client *Client) GetRuleCategory(request *GetRuleCategoryRequest) (response *GetRuleCategoryResponse, err error)

GetRuleCategory invokes the qualitycheck.GetRuleCategory API synchronously

func (*Client) GetRuleCategoryWithCallback ¶

func (client *Client) GetRuleCategoryWithCallback(request *GetRuleCategoryRequest, callback func(response *GetRuleCategoryResponse, err error)) <-chan int

GetRuleCategoryWithCallback invokes the qualitycheck.GetRuleCategory API asynchronously

func (*Client) GetRuleCategoryWithChan ¶

func (client *Client) GetRuleCategoryWithChan(request *GetRuleCategoryRequest) (<-chan *GetRuleCategoryResponse, <-chan error)

GetRuleCategoryWithChan invokes the qualitycheck.GetRuleCategory API asynchronously

func (*Client) GetRuleDetail ¶

func (client *Client) GetRuleDetail(request *GetRuleDetailRequest) (response *GetRuleDetailResponse, err error)

GetRuleDetail invokes the qualitycheck.GetRuleDetail API synchronously

func (*Client) GetRuleDetailWithCallback ¶

func (client *Client) GetRuleDetailWithCallback(request *GetRuleDetailRequest, callback func(response *GetRuleDetailResponse, err error)) <-chan int

GetRuleDetailWithCallback invokes the qualitycheck.GetRuleDetail API asynchronously

func (*Client) GetRuleDetailWithChan ¶

func (client *Client) GetRuleDetailWithChan(request *GetRuleDetailRequest) (<-chan *GetRuleDetailResponse, <-chan error)

GetRuleDetailWithChan invokes the qualitycheck.GetRuleDetail API asynchronously

func (*Client) GetRuleWithCallback ¶

func (client *Client) GetRuleWithCallback(request *GetRuleRequest, callback func(response *GetRuleResponse, err error)) <-chan int

GetRuleWithCallback invokes the qualitycheck.GetRule API asynchronously

func (*Client) GetRuleWithChan ¶

func (client *Client) GetRuleWithChan(request *GetRuleRequest) (<-chan *GetRuleResponse, <-chan error)

GetRuleWithChan invokes the qualitycheck.GetRule API asynchronously

func (*Client) GetScoreInfo ¶

func (client *Client) GetScoreInfo(request *GetScoreInfoRequest) (response *GetScoreInfoResponse, err error)

GetScoreInfo invokes the qualitycheck.GetScoreInfo API synchronously

func (*Client) GetScoreInfoWithCallback ¶

func (client *Client) GetScoreInfoWithCallback(request *GetScoreInfoRequest, callback func(response *GetScoreInfoResponse, err error)) <-chan int

GetScoreInfoWithCallback invokes the qualitycheck.GetScoreInfo API asynchronously

func (*Client) GetScoreInfoWithChan ¶

func (client *Client) GetScoreInfoWithChan(request *GetScoreInfoRequest) (<-chan *GetScoreInfoResponse, <-chan error)

GetScoreInfoWithChan invokes the qualitycheck.GetScoreInfo API asynchronously

func (*Client) GetSkillGroupConfig ¶

func (client *Client) GetSkillGroupConfig(request *GetSkillGroupConfigRequest) (response *GetSkillGroupConfigResponse, err error)

GetSkillGroupConfig invokes the qualitycheck.GetSkillGroupConfig API synchronously

func (*Client) GetSkillGroupConfigWithCallback ¶

func (client *Client) GetSkillGroupConfigWithCallback(request *GetSkillGroupConfigRequest, callback func(response *GetSkillGroupConfigResponse, err error)) <-chan int

GetSkillGroupConfigWithCallback invokes the qualitycheck.GetSkillGroupConfig API asynchronously

func (*Client) GetSkillGroupConfigWithChan ¶

func (client *Client) GetSkillGroupConfigWithChan(request *GetSkillGroupConfigRequest) (<-chan *GetSkillGroupConfigResponse, <-chan error)

GetSkillGroupConfigWithChan invokes the qualitycheck.GetSkillGroupConfig API asynchronously

func (*Client) GetSyncResult ¶

func (client *Client) GetSyncResult(request *GetSyncResultRequest) (response *GetSyncResultResponse, err error)

GetSyncResult invokes the qualitycheck.GetSyncResult API synchronously

func (*Client) GetSyncResultWithCallback ¶

func (client *Client) GetSyncResultWithCallback(request *GetSyncResultRequest, callback func(response *GetSyncResultResponse, err error)) <-chan int

GetSyncResultWithCallback invokes the qualitycheck.GetSyncResult API asynchronously

func (*Client) GetSyncResultWithChan ¶

func (client *Client) GetSyncResultWithChan(request *GetSyncResultRequest) (<-chan *GetSyncResultResponse, <-chan error)

GetSyncResultWithChan invokes the qualitycheck.GetSyncResult API asynchronously

func (*Client) GetThesaurusBySynonymForApi ¶

func (client *Client) GetThesaurusBySynonymForApi(request *GetThesaurusBySynonymForApiRequest) (response *GetThesaurusBySynonymForApiResponse, err error)

GetThesaurusBySynonymForApi invokes the qualitycheck.GetThesaurusBySynonymForApi API synchronously

func (*Client) GetThesaurusBySynonymForApiWithCallback ¶

func (client *Client) GetThesaurusBySynonymForApiWithCallback(request *GetThesaurusBySynonymForApiRequest, callback func(response *GetThesaurusBySynonymForApiResponse, err error)) <-chan int

GetThesaurusBySynonymForApiWithCallback invokes the qualitycheck.GetThesaurusBySynonymForApi API asynchronously

func (*Client) GetThesaurusBySynonymForApiWithChan ¶

func (client *Client) GetThesaurusBySynonymForApiWithChan(request *GetThesaurusBySynonymForApiRequest) (<-chan *GetThesaurusBySynonymForApiResponse, <-chan error)

GetThesaurusBySynonymForApiWithChan invokes the qualitycheck.GetThesaurusBySynonymForApi API asynchronously

func (*Client) HandleComplaint ¶

func (client *Client) HandleComplaint(request *HandleComplaintRequest) (response *HandleComplaintResponse, err error)

HandleComplaint invokes the qualitycheck.HandleComplaint API synchronously

func (*Client) HandleComplaintWithCallback ¶

func (client *Client) HandleComplaintWithCallback(request *HandleComplaintRequest, callback func(response *HandleComplaintResponse, err error)) <-chan int

HandleComplaintWithCallback invokes the qualitycheck.HandleComplaint API asynchronously

func (*Client) HandleComplaintWithChan ¶

func (client *Client) HandleComplaintWithChan(request *HandleComplaintRequest) (<-chan *HandleComplaintResponse, <-chan error)

HandleComplaintWithChan invokes the qualitycheck.HandleComplaint API asynchronously

func (*Client) InsertScoreForApi ¶

func (client *Client) InsertScoreForApi(request *InsertScoreForApiRequest) (response *InsertScoreForApiResponse, err error)

InsertScoreForApi invokes the qualitycheck.InsertScoreForApi API synchronously

func (*Client) InsertScoreForApiWithCallback ¶

func (client *Client) InsertScoreForApiWithCallback(request *InsertScoreForApiRequest, callback func(response *InsertScoreForApiResponse, err error)) <-chan int

InsertScoreForApiWithCallback invokes the qualitycheck.InsertScoreForApi API asynchronously

func (*Client) InsertScoreForApiWithChan ¶

func (client *Client) InsertScoreForApiWithChan(request *InsertScoreForApiRequest) (<-chan *InsertScoreForApiResponse, <-chan error)

InsertScoreForApiWithChan invokes the qualitycheck.InsertScoreForApi API asynchronously

func (*Client) InsertSubScoreForApi ¶

func (client *Client) InsertSubScoreForApi(request *InsertSubScoreForApiRequest) (response *InsertSubScoreForApiResponse, err error)

InsertSubScoreForApi invokes the qualitycheck.InsertSubScoreForApi API synchronously

func (*Client) InsertSubScoreForApiWithCallback ¶

func (client *Client) InsertSubScoreForApiWithCallback(request *InsertSubScoreForApiRequest, callback func(response *InsertSubScoreForApiResponse, err error)) <-chan int

InsertSubScoreForApiWithCallback invokes the qualitycheck.InsertSubScoreForApi API asynchronously

func (*Client) InsertSubScoreForApiWithChan ¶

func (client *Client) InsertSubScoreForApiWithChan(request *InsertSubScoreForApiRequest) (<-chan *InsertSubScoreForApiResponse, <-chan error)

InsertSubScoreForApiWithChan invokes the qualitycheck.InsertSubScoreForApi API asynchronously

func (*Client) InvalidRule ¶

func (client *Client) InvalidRule(request *InvalidRuleRequest) (response *InvalidRuleResponse, err error)

InvalidRule invokes the qualitycheck.InvalidRule API synchronously

func (*Client) InvalidRuleWithCallback ¶

func (client *Client) InvalidRuleWithCallback(request *InvalidRuleRequest, callback func(response *InvalidRuleResponse, err error)) <-chan int

InvalidRuleWithCallback invokes the qualitycheck.InvalidRule API asynchronously

func (*Client) InvalidRuleWithChan ¶

func (client *Client) InvalidRuleWithChan(request *InvalidRuleRequest) (<-chan *InvalidRuleResponse, <-chan error)

InvalidRuleWithChan invokes the qualitycheck.InvalidRule API asynchronously

func (*Client) ListAsrVocab ¶

func (client *Client) ListAsrVocab(request *ListAsrVocabRequest) (response *ListAsrVocabResponse, err error)

ListAsrVocab invokes the qualitycheck.ListAsrVocab API synchronously

func (*Client) ListAsrVocabWithCallback ¶

func (client *Client) ListAsrVocabWithCallback(request *ListAsrVocabRequest, callback func(response *ListAsrVocabResponse, err error)) <-chan int

ListAsrVocabWithCallback invokes the qualitycheck.ListAsrVocab API asynchronously

func (*Client) ListAsrVocabWithChan ¶

func (client *Client) ListAsrVocabWithChan(request *ListAsrVocabRequest) (<-chan *ListAsrVocabResponse, <-chan error)

ListAsrVocabWithChan invokes the qualitycheck.ListAsrVocab API asynchronously

func (*Client) ListBusinessSpaces ¶

func (client *Client) ListBusinessSpaces(request *ListBusinessSpacesRequest) (response *ListBusinessSpacesResponse, err error)

ListBusinessSpaces invokes the qualitycheck.ListBusinessSpaces API synchronously

func (*Client) ListBusinessSpacesWithCallback ¶

func (client *Client) ListBusinessSpacesWithCallback(request *ListBusinessSpacesRequest, callback func(response *ListBusinessSpacesResponse, err error)) <-chan int

ListBusinessSpacesWithCallback invokes the qualitycheck.ListBusinessSpaces API asynchronously

func (*Client) ListBusinessSpacesWithChan ¶

func (client *Client) ListBusinessSpacesWithChan(request *ListBusinessSpacesRequest) (<-chan *ListBusinessSpacesResponse, <-chan error)

ListBusinessSpacesWithChan invokes the qualitycheck.ListBusinessSpaces API asynchronously

func (*Client) ListHotWordsTasks ¶

func (client *Client) ListHotWordsTasks(request *ListHotWordsTasksRequest) (response *ListHotWordsTasksResponse, err error)

ListHotWordsTasks invokes the qualitycheck.ListHotWordsTasks API synchronously

func (*Client) ListHotWordsTasksWithCallback ¶

func (client *Client) ListHotWordsTasksWithCallback(request *ListHotWordsTasksRequest, callback func(response *ListHotWordsTasksResponse, err error)) <-chan int

ListHotWordsTasksWithCallback invokes the qualitycheck.ListHotWordsTasks API asynchronously

func (*Client) ListHotWordsTasksWithChan ¶

func (client *Client) ListHotWordsTasksWithChan(request *ListHotWordsTasksRequest) (<-chan *ListHotWordsTasksResponse, <-chan error)

ListHotWordsTasksWithChan invokes the qualitycheck.ListHotWordsTasks API asynchronously

func (*Client) ListPrecisionTask ¶

func (client *Client) ListPrecisionTask(request *ListPrecisionTaskRequest) (response *ListPrecisionTaskResponse, err error)

ListPrecisionTask invokes the qualitycheck.ListPrecisionTask API synchronously

func (*Client) ListPrecisionTaskWithCallback ¶

func (client *Client) ListPrecisionTaskWithCallback(request *ListPrecisionTaskRequest, callback func(response *ListPrecisionTaskResponse, err error)) <-chan int

ListPrecisionTaskWithCallback invokes the qualitycheck.ListPrecisionTask API asynchronously

func (*Client) ListPrecisionTaskWithChan ¶

func (client *Client) ListPrecisionTaskWithChan(request *ListPrecisionTaskRequest) (<-chan *ListPrecisionTaskResponse, <-chan error)

ListPrecisionTaskWithChan invokes the qualitycheck.ListPrecisionTask API asynchronously

func (*Client) ListQualityCheckScheme ¶

func (client *Client) ListQualityCheckScheme(request *ListQualityCheckSchemeRequest) (response *ListQualityCheckSchemeResponse, err error)

ListQualityCheckScheme invokes the qualitycheck.ListQualityCheckScheme API synchronously

func (*Client) ListQualityCheckSchemeWithCallback ¶

func (client *Client) ListQualityCheckSchemeWithCallback(request *ListQualityCheckSchemeRequest, callback func(response *ListQualityCheckSchemeResponse, err error)) <-chan int

ListQualityCheckSchemeWithCallback invokes the qualitycheck.ListQualityCheckScheme API asynchronously

func (*Client) ListQualityCheckSchemeWithChan ¶

func (client *Client) ListQualityCheckSchemeWithChan(request *ListQualityCheckSchemeRequest) (<-chan *ListQualityCheckSchemeResponse, <-chan error)

ListQualityCheckSchemeWithChan invokes the qualitycheck.ListQualityCheckScheme API asynchronously

func (*Client) ListRoles ¶

func (client *Client) ListRoles(request *ListRolesRequest) (response *ListRolesResponse, err error)

ListRoles invokes the qualitycheck.ListRoles API synchronously

func (*Client) ListRolesWithCallback ¶

func (client *Client) ListRolesWithCallback(request *ListRolesRequest, callback func(response *ListRolesResponse, err error)) <-chan int

ListRolesWithCallback invokes the qualitycheck.ListRoles API asynchronously

func (*Client) ListRolesWithChan ¶

func (client *Client) ListRolesWithChan(request *ListRolesRequest) (<-chan *ListRolesResponse, <-chan error)

ListRolesWithChan invokes the qualitycheck.ListRoles API asynchronously

func (*Client) ListRules ¶

func (client *Client) ListRules(request *ListRulesRequest) (response *ListRulesResponse, err error)

ListRules invokes the qualitycheck.ListRules API synchronously

func (*Client) ListRulesWithCallback ¶

func (client *Client) ListRulesWithCallback(request *ListRulesRequest, callback func(response *ListRulesResponse, err error)) <-chan int

ListRulesWithCallback invokes the qualitycheck.ListRules API asynchronously

func (*Client) ListRulesWithChan ¶

func (client *Client) ListRulesWithChan(request *ListRulesRequest) (<-chan *ListRulesResponse, <-chan error)

ListRulesWithChan invokes the qualitycheck.ListRules API asynchronously

func (*Client) ListSkillGroupConfig ¶

func (client *Client) ListSkillGroupConfig(request *ListSkillGroupConfigRequest) (response *ListSkillGroupConfigResponse, err error)

ListSkillGroupConfig invokes the qualitycheck.ListSkillGroupConfig API synchronously

func (*Client) ListSkillGroupConfigWithCallback ¶

func (client *Client) ListSkillGroupConfigWithCallback(request *ListSkillGroupConfigRequest, callback func(response *ListSkillGroupConfigResponse, err error)) <-chan int

ListSkillGroupConfigWithCallback invokes the qualitycheck.ListSkillGroupConfig API asynchronously

func (*Client) ListSkillGroupConfigWithChan ¶

func (client *Client) ListSkillGroupConfigWithChan(request *ListSkillGroupConfigRequest) (<-chan *ListSkillGroupConfigResponse, <-chan error)

ListSkillGroupConfigWithChan invokes the qualitycheck.ListSkillGroupConfig API asynchronously

func (*Client) ListTaskAssignRules ¶

func (client *Client) ListTaskAssignRules(request *ListTaskAssignRulesRequest) (response *ListTaskAssignRulesResponse, err error)

ListTaskAssignRules invokes the qualitycheck.ListTaskAssignRules API synchronously

func (*Client) ListTaskAssignRulesWithCallback ¶

func (client *Client) ListTaskAssignRulesWithCallback(request *ListTaskAssignRulesRequest, callback func(response *ListTaskAssignRulesResponse, err error)) <-chan int

ListTaskAssignRulesWithCallback invokes the qualitycheck.ListTaskAssignRules API asynchronously

func (*Client) ListTaskAssignRulesWithChan ¶

func (client *Client) ListTaskAssignRulesWithChan(request *ListTaskAssignRulesRequest) (<-chan *ListTaskAssignRulesResponse, <-chan error)

ListTaskAssignRulesWithChan invokes the qualitycheck.ListTaskAssignRules API asynchronously

func (*Client) ListUsers ¶

func (client *Client) ListUsers(request *ListUsersRequest) (response *ListUsersResponse, err error)

ListUsers invokes the qualitycheck.ListUsers API synchronously

func (*Client) ListUsersWithCallback ¶

func (client *Client) ListUsersWithCallback(request *ListUsersRequest, callback func(response *ListUsersResponse, err error)) <-chan int

ListUsersWithCallback invokes the qualitycheck.ListUsers API asynchronously

func (*Client) ListUsersWithChan ¶

func (client *Client) ListUsersWithChan(request *ListUsersRequest) (<-chan *ListUsersResponse, <-chan error)

ListUsersWithChan invokes the qualitycheck.ListUsers API asynchronously

func (*Client) ListWarningConfig ¶

func (client *Client) ListWarningConfig(request *ListWarningConfigRequest) (response *ListWarningConfigResponse, err error)

ListWarningConfig invokes the qualitycheck.ListWarningConfig API synchronously

func (*Client) ListWarningConfigWithCallback ¶

func (client *Client) ListWarningConfigWithCallback(request *ListWarningConfigRequest, callback func(response *ListWarningConfigResponse, err error)) <-chan int

ListWarningConfigWithCallback invokes the qualitycheck.ListWarningConfig API asynchronously

func (*Client) ListWarningConfigWithChan ¶

func (client *Client) ListWarningConfigWithChan(request *ListWarningConfigRequest) (<-chan *ListWarningConfigResponse, <-chan error)

ListWarningConfigWithChan invokes the qualitycheck.ListWarningConfig API asynchronously

func (*Client) RestartAsrTask ¶

func (client *Client) RestartAsrTask(request *RestartAsrTaskRequest) (response *RestartAsrTaskResponse, err error)

RestartAsrTask invokes the qualitycheck.RestartAsrTask API synchronously

func (*Client) RestartAsrTaskWithCallback ¶

func (client *Client) RestartAsrTaskWithCallback(request *RestartAsrTaskRequest, callback func(response *RestartAsrTaskResponse, err error)) <-chan int

RestartAsrTaskWithCallback invokes the qualitycheck.RestartAsrTask API asynchronously

func (*Client) RestartAsrTaskWithChan ¶

func (client *Client) RestartAsrTaskWithChan(request *RestartAsrTaskRequest) (<-chan *RestartAsrTaskResponse, <-chan error)

RestartAsrTaskWithChan invokes the qualitycheck.RestartAsrTask API asynchronously

func (*Client) SaveConfigDataSet ¶

func (client *Client) SaveConfigDataSet(request *SaveConfigDataSetRequest) (response *SaveConfigDataSetResponse, err error)

SaveConfigDataSet invokes the qualitycheck.SaveConfigDataSet API synchronously

func (*Client) SaveConfigDataSetWithCallback ¶

func (client *Client) SaveConfigDataSetWithCallback(request *SaveConfigDataSetRequest, callback func(response *SaveConfigDataSetResponse, err error)) <-chan int

SaveConfigDataSetWithCallback invokes the qualitycheck.SaveConfigDataSet API asynchronously

func (*Client) SaveConfigDataSetWithChan ¶

func (client *Client) SaveConfigDataSetWithChan(request *SaveConfigDataSetRequest) (<-chan *SaveConfigDataSetResponse, <-chan error)

SaveConfigDataSetWithChan invokes the qualitycheck.SaveConfigDataSet API asynchronously

func (*Client) SubmitComplaint ¶

func (client *Client) SubmitComplaint(request *SubmitComplaintRequest) (response *SubmitComplaintResponse, err error)

SubmitComplaint invokes the qualitycheck.SubmitComplaint API synchronously

func (*Client) SubmitComplaintWithCallback ¶

func (client *Client) SubmitComplaintWithCallback(request *SubmitComplaintRequest, callback func(response *SubmitComplaintResponse, err error)) <-chan int

SubmitComplaintWithCallback invokes the qualitycheck.SubmitComplaint API asynchronously

func (*Client) SubmitComplaintWithChan ¶

func (client *Client) SubmitComplaintWithChan(request *SubmitComplaintRequest) (<-chan *SubmitComplaintResponse, <-chan error)

SubmitComplaintWithChan invokes the qualitycheck.SubmitComplaint API asynchronously

func (*Client) SubmitPrecisionTask ¶

func (client *Client) SubmitPrecisionTask(request *SubmitPrecisionTaskRequest) (response *SubmitPrecisionTaskResponse, err error)

SubmitPrecisionTask invokes the qualitycheck.SubmitPrecisionTask API synchronously

func (*Client) SubmitPrecisionTaskWithCallback ¶

func (client *Client) SubmitPrecisionTaskWithCallback(request *SubmitPrecisionTaskRequest, callback func(response *SubmitPrecisionTaskResponse, err error)) <-chan int

SubmitPrecisionTaskWithCallback invokes the qualitycheck.SubmitPrecisionTask API asynchronously

func (*Client) SubmitPrecisionTaskWithChan ¶

func (client *Client) SubmitPrecisionTaskWithChan(request *SubmitPrecisionTaskRequest) (<-chan *SubmitPrecisionTaskResponse, <-chan error)

SubmitPrecisionTaskWithChan invokes the qualitycheck.SubmitPrecisionTask API asynchronously

func (*Client) SubmitQualityCheckTask ¶

func (client *Client) SubmitQualityCheckTask(request *SubmitQualityCheckTaskRequest) (response *SubmitQualityCheckTaskResponse, err error)

SubmitQualityCheckTask invokes the qualitycheck.SubmitQualityCheckTask API synchronously

func (*Client) SubmitQualityCheckTaskWithCallback ¶

func (client *Client) SubmitQualityCheckTaskWithCallback(request *SubmitQualityCheckTaskRequest, callback func(response *SubmitQualityCheckTaskResponse, err error)) <-chan int

SubmitQualityCheckTaskWithCallback invokes the qualitycheck.SubmitQualityCheckTask API asynchronously

func (*Client) SubmitQualityCheckTaskWithChan ¶

func (client *Client) SubmitQualityCheckTaskWithChan(request *SubmitQualityCheckTaskRequest) (<-chan *SubmitQualityCheckTaskResponse, <-chan error)

SubmitQualityCheckTaskWithChan invokes the qualitycheck.SubmitQualityCheckTask API asynchronously

func (*Client) SubmitReviewInfo ¶

func (client *Client) SubmitReviewInfo(request *SubmitReviewInfoRequest) (response *SubmitReviewInfoResponse, err error)

SubmitReviewInfo invokes the qualitycheck.SubmitReviewInfo API synchronously

func (*Client) SubmitReviewInfoWithCallback ¶

func (client *Client) SubmitReviewInfoWithCallback(request *SubmitReviewInfoRequest, callback func(response *SubmitReviewInfoResponse, err error)) <-chan int

SubmitReviewInfoWithCallback invokes the qualitycheck.SubmitReviewInfo API asynchronously

func (*Client) SubmitReviewInfoWithChan ¶

func (client *Client) SubmitReviewInfoWithChan(request *SubmitReviewInfoRequest) (<-chan *SubmitReviewInfoResponse, <-chan error)

SubmitReviewInfoWithChan invokes the qualitycheck.SubmitReviewInfo API asynchronously

func (*Client) SyncQualityCheck ¶

func (client *Client) SyncQualityCheck(request *SyncQualityCheckRequest) (response *SyncQualityCheckResponse, err error)

SyncQualityCheck invokes the qualitycheck.SyncQualityCheck API synchronously

func (*Client) SyncQualityCheckWithCallback ¶

func (client *Client) SyncQualityCheckWithCallback(request *SyncQualityCheckRequest, callback func(response *SyncQualityCheckResponse, err error)) <-chan int

SyncQualityCheckWithCallback invokes the qualitycheck.SyncQualityCheck API asynchronously

func (*Client) SyncQualityCheckWithChan ¶

func (client *Client) SyncQualityCheckWithChan(request *SyncQualityCheckRequest) (<-chan *SyncQualityCheckResponse, <-chan error)

SyncQualityCheckWithChan invokes the qualitycheck.SyncQualityCheck API asynchronously

func (*Client) UpdateAsrVocab ¶

func (client *Client) UpdateAsrVocab(request *UpdateAsrVocabRequest) (response *UpdateAsrVocabResponse, err error)

UpdateAsrVocab invokes the qualitycheck.UpdateAsrVocab API synchronously

func (*Client) UpdateAsrVocabWithCallback ¶

func (client *Client) UpdateAsrVocabWithCallback(request *UpdateAsrVocabRequest, callback func(response *UpdateAsrVocabResponse, err error)) <-chan int

UpdateAsrVocabWithCallback invokes the qualitycheck.UpdateAsrVocab API asynchronously

func (*Client) UpdateAsrVocabWithChan ¶

func (client *Client) UpdateAsrVocabWithChan(request *UpdateAsrVocabRequest) (<-chan *UpdateAsrVocabResponse, <-chan error)

UpdateAsrVocabWithChan invokes the qualitycheck.UpdateAsrVocab API asynchronously

func (*Client) UpdateQualityCheckData ¶

func (client *Client) UpdateQualityCheckData(request *UpdateQualityCheckDataRequest) (response *UpdateQualityCheckDataResponse, err error)

UpdateQualityCheckData invokes the qualitycheck.UpdateQualityCheckData API synchronously

func (*Client) UpdateQualityCheckDataWithCallback ¶

func (client *Client) UpdateQualityCheckDataWithCallback(request *UpdateQualityCheckDataRequest, callback func(response *UpdateQualityCheckDataResponse, err error)) <-chan int

UpdateQualityCheckDataWithCallback invokes the qualitycheck.UpdateQualityCheckData API asynchronously

func (*Client) UpdateQualityCheckDataWithChan ¶

func (client *Client) UpdateQualityCheckDataWithChan(request *UpdateQualityCheckDataRequest) (<-chan *UpdateQualityCheckDataResponse, <-chan error)

UpdateQualityCheckDataWithChan invokes the qualitycheck.UpdateQualityCheckData API asynchronously

func (*Client) UpdateRule ¶

func (client *Client) UpdateRule(request *UpdateRuleRequest) (response *UpdateRuleResponse, err error)

UpdateRule invokes the qualitycheck.UpdateRule API synchronously

func (*Client) UpdateRuleWithCallback ¶

func (client *Client) UpdateRuleWithCallback(request *UpdateRuleRequest, callback func(response *UpdateRuleResponse, err error)) <-chan int

UpdateRuleWithCallback invokes the qualitycheck.UpdateRule API asynchronously

func (*Client) UpdateRuleWithChan ¶

func (client *Client) UpdateRuleWithChan(request *UpdateRuleRequest) (<-chan *UpdateRuleResponse, <-chan error)

UpdateRuleWithChan invokes the qualitycheck.UpdateRule API asynchronously

func (*Client) UpdateScoreForApi ¶

func (client *Client) UpdateScoreForApi(request *UpdateScoreForApiRequest) (response *UpdateScoreForApiResponse, err error)

UpdateScoreForApi invokes the qualitycheck.UpdateScoreForApi API synchronously

func (*Client) UpdateScoreForApiWithCallback ¶

func (client *Client) UpdateScoreForApiWithCallback(request *UpdateScoreForApiRequest, callback func(response *UpdateScoreForApiResponse, err error)) <-chan int

UpdateScoreForApiWithCallback invokes the qualitycheck.UpdateScoreForApi API asynchronously

func (*Client) UpdateScoreForApiWithChan ¶

func (client *Client) UpdateScoreForApiWithChan(request *UpdateScoreForApiRequest) (<-chan *UpdateScoreForApiResponse, <-chan error)

UpdateScoreForApiWithChan invokes the qualitycheck.UpdateScoreForApi API asynchronously

func (*Client) UpdateSkillGroupConfig ¶

func (client *Client) UpdateSkillGroupConfig(request *UpdateSkillGroupConfigRequest) (response *UpdateSkillGroupConfigResponse, err error)

UpdateSkillGroupConfig invokes the qualitycheck.UpdateSkillGroupConfig API synchronously

func (*Client) UpdateSkillGroupConfigWithCallback ¶

func (client *Client) UpdateSkillGroupConfigWithCallback(request *UpdateSkillGroupConfigRequest, callback func(response *UpdateSkillGroupConfigResponse, err error)) <-chan int

UpdateSkillGroupConfigWithCallback invokes the qualitycheck.UpdateSkillGroupConfig API asynchronously

func (*Client) UpdateSkillGroupConfigWithChan ¶

func (client *Client) UpdateSkillGroupConfigWithChan(request *UpdateSkillGroupConfigRequest) (<-chan *UpdateSkillGroupConfigResponse, <-chan error)

UpdateSkillGroupConfigWithChan invokes the qualitycheck.UpdateSkillGroupConfig API asynchronously

func (*Client) UpdateSubScoreForApi ¶

func (client *Client) UpdateSubScoreForApi(request *UpdateSubScoreForApiRequest) (response *UpdateSubScoreForApiResponse, err error)

UpdateSubScoreForApi invokes the qualitycheck.UpdateSubScoreForApi API synchronously

func (*Client) UpdateSubScoreForApiWithCallback ¶

func (client *Client) UpdateSubScoreForApiWithCallback(request *UpdateSubScoreForApiRequest, callback func(response *UpdateSubScoreForApiResponse, err error)) <-chan int

UpdateSubScoreForApiWithCallback invokes the qualitycheck.UpdateSubScoreForApi API asynchronously

func (*Client) UpdateSubScoreForApiWithChan ¶

func (client *Client) UpdateSubScoreForApiWithChan(request *UpdateSubScoreForApiRequest) (<-chan *UpdateSubScoreForApiResponse, <-chan error)

UpdateSubScoreForApiWithChan invokes the qualitycheck.UpdateSubScoreForApi API asynchronously

func (*Client) UpdateSyncQualityCheckData ¶

func (client *Client) UpdateSyncQualityCheckData(request *UpdateSyncQualityCheckDataRequest) (response *UpdateSyncQualityCheckDataResponse, err error)

UpdateSyncQualityCheckData invokes the qualitycheck.UpdateSyncQualityCheckData API synchronously

func (*Client) UpdateSyncQualityCheckDataWithCallback ¶

func (client *Client) UpdateSyncQualityCheckDataWithCallback(request *UpdateSyncQualityCheckDataRequest, callback func(response *UpdateSyncQualityCheckDataResponse, err error)) <-chan int

UpdateSyncQualityCheckDataWithCallback invokes the qualitycheck.UpdateSyncQualityCheckData API asynchronously

func (*Client) UpdateSyncQualityCheckDataWithChan ¶

func (client *Client) UpdateSyncQualityCheckDataWithChan(request *UpdateSyncQualityCheckDataRequest) (<-chan *UpdateSyncQualityCheckDataResponse, <-chan error)

UpdateSyncQualityCheckDataWithChan invokes the qualitycheck.UpdateSyncQualityCheckData API asynchronously

func (*Client) UpdateTaskAssignRule ¶

func (client *Client) UpdateTaskAssignRule(request *UpdateTaskAssignRuleRequest) (response *UpdateTaskAssignRuleResponse, err error)

UpdateTaskAssignRule invokes the qualitycheck.UpdateTaskAssignRule API synchronously

func (*Client) UpdateTaskAssignRuleWithCallback ¶

func (client *Client) UpdateTaskAssignRuleWithCallback(request *UpdateTaskAssignRuleRequest, callback func(response *UpdateTaskAssignRuleResponse, err error)) <-chan int

UpdateTaskAssignRuleWithCallback invokes the qualitycheck.UpdateTaskAssignRule API asynchronously

func (*Client) UpdateTaskAssignRuleWithChan ¶

func (client *Client) UpdateTaskAssignRuleWithChan(request *UpdateTaskAssignRuleRequest) (<-chan *UpdateTaskAssignRuleResponse, <-chan error)

UpdateTaskAssignRuleWithChan invokes the qualitycheck.UpdateTaskAssignRule API asynchronously

func (*Client) UpdateUser ¶

func (client *Client) UpdateUser(request *UpdateUserRequest) (response *UpdateUserResponse, err error)

UpdateUser invokes the qualitycheck.UpdateUser API synchronously

func (*Client) UpdateUserConfig ¶

func (client *Client) UpdateUserConfig(request *UpdateUserConfigRequest) (response *UpdateUserConfigResponse, err error)

UpdateUserConfig invokes the qualitycheck.UpdateUserConfig API synchronously

func (*Client) UpdateUserConfigWithCallback ¶

func (client *Client) UpdateUserConfigWithCallback(request *UpdateUserConfigRequest, callback func(response *UpdateUserConfigResponse, err error)) <-chan int

UpdateUserConfigWithCallback invokes the qualitycheck.UpdateUserConfig API asynchronously

func (*Client) UpdateUserConfigWithChan ¶

func (client *Client) UpdateUserConfigWithChan(request *UpdateUserConfigRequest) (<-chan *UpdateUserConfigResponse, <-chan error)

UpdateUserConfigWithChan invokes the qualitycheck.UpdateUserConfig API asynchronously

func (*Client) UpdateUserWithCallback ¶

func (client *Client) UpdateUserWithCallback(request *UpdateUserRequest, callback func(response *UpdateUserResponse, err error)) <-chan int

UpdateUserWithCallback invokes the qualitycheck.UpdateUser API asynchronously

func (*Client) UpdateUserWithChan ¶

func (client *Client) UpdateUserWithChan(request *UpdateUserRequest) (<-chan *UpdateUserResponse, <-chan error)

UpdateUserWithChan invokes the qualitycheck.UpdateUser API asynchronously

func (*Client) UpdateWarningConfig ¶

func (client *Client) UpdateWarningConfig(request *UpdateWarningConfigRequest) (response *UpdateWarningConfigResponse, err error)

UpdateWarningConfig invokes the qualitycheck.UpdateWarningConfig API synchronously

func (*Client) UpdateWarningConfigWithCallback ¶

func (client *Client) UpdateWarningConfigWithCallback(request *UpdateWarningConfigRequest, callback func(response *UpdateWarningConfigResponse, err error)) <-chan int

UpdateWarningConfigWithCallback invokes the qualitycheck.UpdateWarningConfig API asynchronously

func (*Client) UpdateWarningConfigWithChan ¶

func (client *Client) UpdateWarningConfigWithChan(request *UpdateWarningConfigRequest) (<-chan *UpdateWarningConfigResponse, <-chan error)

UpdateWarningConfigWithChan invokes the qualitycheck.UpdateWarningConfig API asynchronously

func (*Client) UploadAudioData ¶

func (client *Client) UploadAudioData(request *UploadAudioDataRequest) (response *UploadAudioDataResponse, err error)

UploadAudioData invokes the qualitycheck.UploadAudioData API synchronously

func (*Client) UploadAudioDataWithCallback ¶

func (client *Client) UploadAudioDataWithCallback(request *UploadAudioDataRequest, callback func(response *UploadAudioDataResponse, err error)) <-chan int

UploadAudioDataWithCallback invokes the qualitycheck.UploadAudioData API asynchronously

func (*Client) UploadAudioDataWithChan ¶

func (client *Client) UploadAudioDataWithChan(request *UploadAudioDataRequest) (<-chan *UploadAudioDataResponse, <-chan error)

UploadAudioDataWithChan invokes the qualitycheck.UploadAudioData API asynchronously

func (*Client) UploadData ¶

func (client *Client) UploadData(request *UploadDataRequest) (response *UploadDataResponse, err error)

UploadData invokes the qualitycheck.UploadData API synchronously

func (*Client) UploadDataSync ¶

func (client *Client) UploadDataSync(request *UploadDataSyncRequest) (response *UploadDataSyncResponse, err error)

UploadDataSync invokes the qualitycheck.UploadDataSync API synchronously

func (*Client) UploadDataSyncWithCallback ¶

func (client *Client) UploadDataSyncWithCallback(request *UploadDataSyncRequest, callback func(response *UploadDataSyncResponse, err error)) <-chan int

UploadDataSyncWithCallback invokes the qualitycheck.UploadDataSync API asynchronously

func (*Client) UploadDataSyncWithChan ¶

func (client *Client) UploadDataSyncWithChan(request *UploadDataSyncRequest) (<-chan *UploadDataSyncResponse, <-chan error)

UploadDataSyncWithChan invokes the qualitycheck.UploadDataSync API asynchronously

func (*Client) UploadDataWithCallback ¶

func (client *Client) UploadDataWithCallback(request *UploadDataRequest, callback func(response *UploadDataResponse, err error)) <-chan int

UploadDataWithCallback invokes the qualitycheck.UploadData API asynchronously

func (*Client) UploadDataWithChan ¶

func (client *Client) UploadDataWithChan(request *UploadDataRequest) (<-chan *UploadDataResponse, <-chan error)

UploadDataWithChan invokes the qualitycheck.UploadData API asynchronously

func (*Client) UploadRule ¶

func (client *Client) UploadRule(request *UploadRuleRequest) (response *UploadRuleResponse, err error)

UploadRule invokes the qualitycheck.UploadRule API synchronously

func (*Client) UploadRuleWithCallback ¶

func (client *Client) UploadRuleWithCallback(request *UploadRuleRequest, callback func(response *UploadRuleResponse, err error)) <-chan int

UploadRuleWithCallback invokes the qualitycheck.UploadRule API asynchronously

func (*Client) UploadRuleWithChan ¶

func (client *Client) UploadRuleWithChan(request *UploadRuleRequest) (<-chan *UploadRuleResponse, <-chan error)

UploadRuleWithChan invokes the qualitycheck.UploadRule API asynchronously

func (*Client) VerifyFile ¶

func (client *Client) VerifyFile(request *VerifyFileRequest) (response *VerifyFileResponse, err error)

VerifyFile invokes the qualitycheck.VerifyFile API synchronously

func (*Client) VerifyFileWithCallback ¶

func (client *Client) VerifyFileWithCallback(request *VerifyFileRequest, callback func(response *VerifyFileResponse, err error)) <-chan int

VerifyFileWithCallback invokes the qualitycheck.VerifyFile API asynchronously

func (*Client) VerifyFileWithChan ¶

func (client *Client) VerifyFileWithChan(request *VerifyFileRequest) (<-chan *VerifyFileResponse, <-chan error)

VerifyFileWithChan invokes the qualitycheck.VerifyFile API asynchronously

func (*Client) VerifySentence ¶

func (client *Client) VerifySentence(request *VerifySentenceRequest) (response *VerifySentenceResponse, err error)

VerifySentence invokes the qualitycheck.VerifySentence API synchronously

func (*Client) VerifySentenceWithCallback ¶

func (client *Client) VerifySentenceWithCallback(request *VerifySentenceRequest, callback func(response *VerifySentenceResponse, err error)) <-chan int

VerifySentenceWithCallback invokes the qualitycheck.VerifySentence API asynchronously

func (*Client) VerifySentenceWithChan ¶

func (client *Client) VerifySentenceWithChan(request *VerifySentenceRequest) (<-chan *VerifySentenceResponse, <-chan error)

VerifySentenceWithChan invokes the qualitycheck.VerifySentence API asynchronously

type ComplainHistoriesInGetResultToReview ¶

type ComplainHistoriesInGetResultToReview struct {
	ComplainHistoriesItem []ComplainHistoriesItem `json:"ComplainHistories" xml:"ComplainHistories"`
}

ComplainHistoriesInGetResultToReview is a nested struct in qualitycheck response

type ComplainHistoriesItem ¶

type ComplainHistoriesItem struct {
	Comments      string `json:"Comments" xml:"Comments"`
	Operator      int64  `json:"Operator" xml:"Operator"`
	OperationTime string `json:"OperationTime" xml:"OperationTime"`
	OperatorName  string `json:"OperatorName" xml:"OperatorName"`
	OperationType int    `json:"OperationType" xml:"OperationType"`
}

ComplainHistoriesItem is a nested struct in qualitycheck response

type ConditionBasicInfo ¶

type ConditionBasicInfo struct {
	ConditionInfoCid string     `json:"ConditionInfoCid" xml:"ConditionInfoCid"`
	OperLambda       string     `json:"OperLambda" xml:"OperLambda"`
	CheckRange       CheckRange `json:"CheckRange" xml:"CheckRange"`
	Operators        Operators  `json:"Operators" xml:"Operators"`
}

ConditionBasicInfo is a nested struct in qualitycheck response

type ConditionHitInfo ¶

type ConditionHitInfo struct {
	Cid         CidInGetResultToReview      `json:"Cid" xml:"Cid"`
	HitCids     HitCids                     `json:"HitCids" xml:"HitCids"`
	Phrase      PhraseInGetResultToReview   `json:"Phrase" xml:"Phrase"`
	KeyWords    KeyWordsInGetResultToReview `json:"KeyWords" xml:"KeyWords"`
	HitKeyWords HitKeyWordsInUploadDataSync `json:"HitKeyWords" xml:"HitKeyWords"`
}

ConditionHitInfo is a nested struct in qualitycheck response

type ConditionHitInfoInSyncQualityCheck ¶

type ConditionHitInfoInSyncQualityCheck struct {
	Phrase      PhraseInSyncQualityCheck `json:"Phrase" xml:"Phrase"`
	HitKeyWords []HitKeyWord             `json:"HitKeyWords" xml:"HitKeyWords"`
}

ConditionHitInfoInSyncQualityCheck is a nested struct in qualitycheck response

type ConditionHitInfoList ¶

type ConditionHitInfoList struct {
	ConditionHitInfo []ConditionHitInfo `json:"ConditionHitInfo" xml:"ConditionHitInfo"`
}

ConditionHitInfoList is a nested struct in qualitycheck response

type ConditionInfo ¶

type ConditionInfo struct {
	ConditionBasicInfo []ConditionBasicInfo `json:"ConditionBasicInfo" xml:"ConditionBasicInfo"`
}

ConditionInfo is a nested struct in qualitycheck response

type Conditions ¶

type Conditions struct {
	ConditionBasicInfo []ConditionBasicInfo `json:"ConditionBasicInfo" xml:"ConditionBasicInfo"`
}

Conditions is a nested struct in qualitycheck response

type CreateAsrVocabRequest ¶

type CreateAsrVocabRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

CreateAsrVocabRequest is the request struct for api CreateAsrVocab

func CreateCreateAsrVocabRequest ¶

func CreateCreateAsrVocabRequest() (request *CreateAsrVocabRequest)

CreateCreateAsrVocabRequest creates a request to invoke CreateAsrVocab API

type CreateAsrVocabResponse ¶

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

CreateAsrVocabResponse is the response struct for api CreateAsrVocab

func CreateCreateAsrVocabResponse ¶

func CreateCreateAsrVocabResponse() (response *CreateAsrVocabResponse)

CreateCreateAsrVocabResponse creates a response to parse from CreateAsrVocab response

type CreateSkillGroupConfigRequest ¶

type CreateSkillGroupConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

CreateSkillGroupConfigRequest is the request struct for api CreateSkillGroupConfig

func CreateCreateSkillGroupConfigRequest ¶

func CreateCreateSkillGroupConfigRequest() (request *CreateSkillGroupConfigRequest)

CreateCreateSkillGroupConfigRequest creates a request to invoke CreateSkillGroupConfig API

type CreateSkillGroupConfigResponse ¶

type CreateSkillGroupConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      int64  `json:"Data" xml:"Data"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

CreateSkillGroupConfigResponse is the response struct for api CreateSkillGroupConfig

func CreateCreateSkillGroupConfigResponse ¶

func CreateCreateSkillGroupConfigResponse() (response *CreateSkillGroupConfigResponse)

CreateCreateSkillGroupConfigResponse creates a response to parse from CreateSkillGroupConfig response

type CreateTaskAssignRuleRequest ¶

type CreateTaskAssignRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

CreateTaskAssignRuleRequest is the request struct for api CreateTaskAssignRule

func CreateCreateTaskAssignRuleRequest ¶

func CreateCreateTaskAssignRuleRequest() (request *CreateTaskAssignRuleRequest)

CreateCreateTaskAssignRuleRequest creates a request to invoke CreateTaskAssignRule API

type CreateTaskAssignRuleResponse ¶

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

CreateTaskAssignRuleResponse is the response struct for api CreateTaskAssignRule

func CreateCreateTaskAssignRuleResponse ¶

func CreateCreateTaskAssignRuleResponse() (response *CreateTaskAssignRuleResponse)

CreateCreateTaskAssignRuleResponse creates a response to parse from CreateTaskAssignRule response

type CreateUserRequest ¶

type CreateUserRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

CreateUserRequest is the request struct for api CreateUser

func CreateCreateUserRequest ¶

func CreateCreateUserRequest() (request *CreateUserRequest)

CreateCreateUserRequest creates a request to invoke CreateUser API

type CreateUserResponse ¶

type CreateUserResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

CreateUserResponse is the response struct for api CreateUser

func CreateCreateUserResponse ¶

func CreateCreateUserResponse() (response *CreateUserResponse)

CreateCreateUserResponse creates a response to parse from CreateUser response

type CreateWarningConfigRequest ¶

type CreateWarningConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

CreateWarningConfigRequest is the request struct for api CreateWarningConfig

func CreateCreateWarningConfigRequest ¶

func CreateCreateWarningConfigRequest() (request *CreateWarningConfigRequest)

CreateCreateWarningConfigRequest creates a request to invoke CreateWarningConfig API

type CreateWarningConfigResponse ¶

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

CreateWarningConfigResponse is the response struct for api CreateWarningConfig

func CreateCreateWarningConfigResponse ¶

func CreateCreateWarningConfigResponse() (response *CreateWarningConfigResponse)

CreateCreateWarningConfigResponse creates a response to parse from CreateWarningConfig response

type Data ¶

type Data struct {
	SkillGroupFrom         int                              `json:"SkillGroupFrom" xml:"SkillGroupFrom"`
	Vid                    string                           `json:"Vid" xml:"Vid"`
	ModelName              string                           `json:"ModelName" xml:"ModelName"`
	TaskId                 string                           `json:"TaskId" xml:"TaskId"`
	SkillGroupId           string                           `json:"SkillGroupId" xml:"SkillGroupId"`
	ReviewNumber           int                              `json:"ReviewNumber" xml:"ReviewNumber"`
	QualityCheckType       int                              `json:"QualityCheckType" xml:"QualityCheckType"`
	TotalCount             int                              `json:"TotalCount" xml:"TotalCount"`
	FileName               string                           `json:"FileName" xml:"FileName"`
	FileId                 string                           `json:"FileId" xml:"FileId"`
	IncorrectWords         int                              `json:"IncorrectWords" xml:"IncorrectWords"`
	AllRids                string                           `json:"AllRids" xml:"AllRids"`
	VerifiedCount          int                              `json:"VerifiedCount" xml:"VerifiedCount"`
	Id                     int64                            `json:"Id" xml:"Id"`
	Precision              float64                          `json:"Precision" xml:"Precision"`
	ModelId                int64                            `json:"ModelId" xml:"ModelId"`
	Verified               bool                             `json:"Verified" xml:"Verified"`
	AllContentQualityCheck int                              `json:"AllContentQualityCheck" xml:"AllContentQualityCheck"`
	Rid                    string                           `json:"Rid" xml:"Rid"`
	ScoreName              string                           `json:"ScoreName" xml:"ScoreName"`
	HitNumber              int                              `json:"HitNumber" xml:"HitNumber"`
	Type                   int                              `json:"Type" xml:"Type"`
	Name                   string                           `json:"Name" xml:"Name"`
	Comments               string                           `json:"Comments" xml:"Comments"`
	VocabId                int64                            `json:"VocabId" xml:"VocabId"`
	VocabName              string                           `json:"VocabName" xml:"VocabName"`
	CreateTime             string                           `json:"CreateTime" xml:"CreateTime"`
	FileMergeName          string                           `json:"FileMergeName" xml:"FileMergeName"`
	AudioScheme            string                           `json:"AudioScheme" xml:"AudioScheme"`
	Index                  int                              `json:"Index" xml:"Index"`
	Tid                    string                           `json:"Tid" xml:"Tid"`
	SkillGroupName         string                           `json:"SkillGroupName" xml:"SkillGroupName"`
	ScoreSubId             int64                            `json:"ScoreSubId" xml:"ScoreSubId"`
	ScoreSubName           string                           `json:"ScoreSubName" xml:"ScoreSubName"`
	Duration               int                              `json:"Duration" xml:"Duration"`
	InstanceId             string                           `json:"InstanceId" xml:"InstanceId"`
	BusinessType           int                              `json:"BusinessType" xml:"BusinessType"`
	TotalScore             int                              `json:"TotalScore" xml:"TotalScore"`
	Audio                  bool                             `json:"Audio" xml:"Audio"`
	Status                 int                              `json:"Status" xml:"Status"`
	UpdateTime             string                           `json:"UpdateTime" xml:"UpdateTime"`
	Source                 int                              `json:"Source" xml:"Source"`
	Select                 bool                             `json:"Select" xml:"Select"`
	AudioURL               string                           `json:"AudioURL" xml:"AudioURL"`
	ScoreId                int64                            `json:"ScoreId" xml:"ScoreId"`
	DataSetName            string                           `json:"DataSetName" xml:"DataSetName"`
	Deleted                bool                             `json:"Deleted" xml:"Deleted"`
	DataSetId              int64                            `json:"DataSetId" xml:"DataSetId"`
	Rules                  RulesInGetRule                   `json:"Rules" xml:"Rules"`
	Dialogues              DialoguesInGetNextResultToVerify `json:"Dialogues" xml:"Dialogues"`
	Precisions             PrecisionsInGetPrecisionTask     `json:"Precisions" xml:"Precisions"`
	ManualScoreInfoList    ManualScoreInfoList              `json:"ManualScoreInfoList" xml:"ManualScoreInfoList"`
	HandScoreInfoList      HandScoreInfoList                `json:"HandScoreInfoList" xml:"HandScoreInfoList"`
	AllRuleList            AllRuleListInGetSkillGroupConfig `json:"AllRuleList" xml:"AllRuleList"`
	Words                  Words                            `json:"Words" xml:"Words"`
	HitRuleReviewInfoList  HitRuleReviewInfoList            `json:"HitRuleReviewInfoList" xml:"HitRuleReviewInfoList"`
	ReviewHistoryList      ReviewHistoryList                `json:"ReviewHistoryList" xml:"ReviewHistoryList"`
	RuleList               RuleListInGetSkillGroupConfig    `json:"RuleList" xml:"RuleList"`
}

Data is a nested struct in qualitycheck response

type DataInGetBusinessCategoryList ¶

type DataInGetBusinessCategoryList struct {
	BusinessCategoryBasicInfo []BusinessCategoryBasicInfo `json:"BusinessCategoryBasicInfo" xml:"BusinessCategoryBasicInfo"`
}

DataInGetBusinessCategoryList is a nested struct in qualitycheck response

type DataInGetCustomizationConfigList ¶

type DataInGetCustomizationConfigList struct {
	ModelCustomizationDataSetPo []ModelCustomizationDataSetPo `json:"ModelCustomizationDataSetPo" xml:"ModelCustomizationDataSetPo"`
}

DataInGetCustomizationConfigList is a nested struct in qualitycheck response

type DataInGetHitResult ¶

type DataInGetHitResult struct {
	ResultInfo []ResultInfo `json:"ResultInfo" xml:"ResultInfo"`
}

DataInGetHitResult is a nested struct in qualitycheck response

type DataInGetResult ¶

type DataInGetResult struct {
	ResultInfo []ResultInfo `json:"ResultInfo" xml:"ResultInfo"`
}

DataInGetResult is a nested struct in qualitycheck response

type DataInGetRuleCategory ¶

type DataInGetRuleCategory struct {
	RuleCountInfo []RuleCountInfo `json:"RuleCountInfo" xml:"RuleCountInfo"`
}

DataInGetRuleCategory is a nested struct in qualitycheck response

type DataInGetRuleDetail ¶

type DataInGetRuleDetail struct {
	PageSize   int                  `json:"PageSize" xml:"PageSize"`
	PageNumber int                  `json:"PageNumber" xml:"PageNumber"`
	Count      int                  `json:"Count" xml:"Count"`
	Conditions Conditions           `json:"Conditions" xml:"Conditions"`
	Rules      RulesInGetRuleDetail `json:"Rules" xml:"Rules"`
}

DataInGetRuleDetail is a nested struct in qualitycheck response

type DataInGetScoreInfo ¶

type DataInGetScoreInfo struct {
	ScorePo []ScorePoInGetScoreInfo `json:"ScorePo" xml:"ScorePo"`
}

DataInGetScoreInfo is a nested struct in qualitycheck response

type DataInGetSyncResult ¶

type DataInGetSyncResult struct {
	ResultInfo []ResultInfoInGetSyncResult `json:"ResultInfo" xml:"ResultInfo"`
}

DataInGetSyncResult is a nested struct in qualitycheck response

type DataInGetThesaurusBySynonymForApi ¶

type DataInGetThesaurusBySynonymForApi struct {
	ThesaurusPo []ThesaurusPo `json:"ThesaurusPo" xml:"ThesaurusPo"`
}

DataInGetThesaurusBySynonymForApi is a nested struct in qualitycheck response

type DataInListAsrVocab ¶

type DataInListAsrVocab struct {
	AsrVocab []AsrVocab `json:"AsrVocab" xml:"AsrVocab"`
}

DataInListAsrVocab is a nested struct in qualitycheck response

type DataInListBusinessSpaces ¶

type DataInListBusinessSpaces struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInListBusinessSpaces is a nested struct in qualitycheck response

type DataInListHotWordsTasks ¶

type DataInListHotWordsTasks struct {
	HotWordsTaskPo []HotWordsTaskPo `json:"HotWordsTaskPo" xml:"HotWordsTaskPo"`
}

DataInListHotWordsTasks is a nested struct in qualitycheck response

type DataInListPrecisionTask ¶

type DataInListPrecisionTask struct {
	PrecisionTask []PrecisionTask `json:"PrecisionTask" xml:"PrecisionTask"`
}

DataInListPrecisionTask is a nested struct in qualitycheck response

type DataInListQualityCheckScheme ¶

type DataInListQualityCheckScheme struct {
	SchemeId            int64                 `json:"SchemeId" xml:"SchemeId"`
	Name                string                `json:"Name" xml:"Name"`
	Description         string                `json:"Description" xml:"Description"`
	DataType            int                   `json:"DataType" xml:"DataType"`
	Type                int                   `json:"Type" xml:"Type"`
	TemplateType        int                   `json:"TemplateType" xml:"TemplateType"`
	Status              int                   `json:"Status" xml:"Status"`
	CreateUserName      string                `json:"CreateUserName" xml:"CreateUserName"`
	CreateTime          string                `json:"CreateTime" xml:"CreateTime"`
	UpdateUserName      string                `json:"UpdateUserName" xml:"UpdateUserName"`
	UpdateTime          string                `json:"UpdateTime" xml:"UpdateTime"`
	Version             int64                 `json:"Version" xml:"Version"`
	SchemeCheckTypeList []SchemeCheckTypeList `json:"SchemeCheckTypeList" xml:"SchemeCheckTypeList"`
	RuleList            []RuleList            `json:"RuleList" xml:"RuleList"`
}

DataInListQualityCheckScheme is a nested struct in qualitycheck response

type DataInListRoles ¶

type DataInListRoles struct {
	Role []Role `json:"Role" xml:"Role"`
}

DataInListRoles is a nested struct in qualitycheck response

type DataInListRules ¶

type DataInListRules struct {
	Rule []Rule `json:"Rule" xml:"Rule"`
}

DataInListRules is a nested struct in qualitycheck response

type DataInListSkillGroupConfig ¶

type DataInListSkillGroupConfig struct {
	SkillGroupConfig []SkillGroupConfig `json:"SkillGroupConfig" xml:"SkillGroupConfig"`
}

DataInListSkillGroupConfig is a nested struct in qualitycheck response

type DataInListTaskAssignRules ¶

type DataInListTaskAssignRules struct {
	TaskAssignRuleInfo []TaskAssignRuleInfo `json:"TaskAssignRuleInfo" xml:"TaskAssignRuleInfo"`
}

DataInListTaskAssignRules is a nested struct in qualitycheck response

type DataInListUsers ¶

type DataInListUsers struct {
	User []User `json:"User" xml:"User"`
}

DataInListUsers is a nested struct in qualitycheck response

type DataInListWarningConfig ¶

type DataInListWarningConfig struct {
	WarningConfigInfo []WarningConfigInfo `json:"WarningConfigInfo" xml:"WarningConfigInfo"`
}

DataInListWarningConfig is a nested struct in qualitycheck response

type DataInRestartAsrTask ¶

type DataInRestartAsrTask struct {
	RestartResult []RestartResult `json:"RestartResult" xml:"RestartResult"`
}

DataInRestartAsrTask is a nested struct in qualitycheck response

type DataInSyncQualityCheck ¶

type DataInSyncQualityCheck struct {
	Score     int           `json:"Score" xml:"Score"`
	TaskId    string        `json:"TaskId" xml:"TaskId"`
	Tid       string        `json:"Tid" xml:"Tid"`
	BeginTime int64         `json:"BeginTime" xml:"BeginTime"`
	Rules     []RuleHitInfo `json:"Rules" xml:"Rules"`
}

DataInSyncQualityCheck is a nested struct in qualitycheck response

type DataInUploadDataSync ¶

type DataInUploadDataSync struct {
	ResultInfo []ResultInfo `json:"ResultInfo" xml:"ResultInfo"`
}

DataInUploadDataSync is a nested struct in qualitycheck response

type DataInUploadRule ¶

type DataInUploadRule struct {
	RidInfo []string `json:"RidInfo" xml:"RidInfo"`
}

DataInUploadRule is a nested struct in qualitycheck response

type DataInVerifySentence ¶

type DataInVerifySentence struct {
	Delta []Delta `json:"Delta" xml:"Delta"`
}

DataInVerifySentence is a nested struct in qualitycheck response

type DataItem ¶

type DataItem struct {
	Id                  int64  `json:"Id" xml:"Id"`
	AliUid              int64  `json:"AliUid" xml:"AliUid"`
	SubAliUid           int64  `json:"SubAliUid" xml:"SubAliUid"`
	RoleName            string `json:"RoleName" xml:"RoleName"`
	LoginUserType       int    `json:"LoginUserType" xml:"LoginUserType"`
	BusinessSpaceCode   string `json:"BusinessSpaceCode" xml:"BusinessSpaceCode"`
	BusinessSpaceName   string `json:"BusinessSpaceName" xml:"BusinessSpaceName"`
	OrderInstanceId     string `json:"OrderInstanceId" xml:"OrderInstanceId"`
	XspaceProductCode   string `json:"XspaceProductCode" xml:"XspaceProductCode"`
	XspaceCommodityCode string `json:"XspaceCommodityCode" xml:"XspaceCommodityCode"`
	ProductType         string `json:"ProductType" xml:"ProductType"`
	Language            string `json:"Language" xml:"Language"`
	StartTime           string `json:"StartTime" xml:"StartTime"`
	EndTime             string `json:"EndTime" xml:"EndTime"`
	CurrentStatus       int    `json:"CurrentStatus" xml:"CurrentStatus"`
}

DataItem is a nested struct in qualitycheck response

type DelRuleCategoryRequest ¶

type DelRuleCategoryRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DelRuleCategoryRequest is the request struct for api DelRuleCategory

func CreateDelRuleCategoryRequest ¶

func CreateDelRuleCategoryRequest() (request *DelRuleCategoryRequest)

CreateDelRuleCategoryRequest creates a request to invoke DelRuleCategory API

type DelRuleCategoryResponse ¶

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

DelRuleCategoryResponse is the response struct for api DelRuleCategory

func CreateDelRuleCategoryResponse ¶

func CreateDelRuleCategoryResponse() (response *DelRuleCategoryResponse)

CreateDelRuleCategoryResponse creates a response to parse from DelRuleCategory response

type DelThesaurusForApiRequest ¶

type DelThesaurusForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DelThesaurusForApiRequest is the request struct for api DelThesaurusForApi

func CreateDelThesaurusForApiRequest ¶

func CreateDelThesaurusForApiRequest() (request *DelThesaurusForApiRequest)

CreateDelThesaurusForApiRequest creates a request to invoke DelThesaurusForApi API

type DelThesaurusForApiResponse ¶

type DelThesaurusForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DelThesaurusForApiResponse is the response struct for api DelThesaurusForApi

func CreateDelThesaurusForApiResponse ¶

func CreateDelThesaurusForApiResponse() (response *DelThesaurusForApiResponse)

CreateDelThesaurusForApiResponse creates a response to parse from DelThesaurusForApi response

type DeleteAsrVocabRequest ¶

type DeleteAsrVocabRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteAsrVocabRequest is the request struct for api DeleteAsrVocab

func CreateDeleteAsrVocabRequest ¶

func CreateDeleteAsrVocabRequest() (request *DeleteAsrVocabRequest)

CreateDeleteAsrVocabRequest creates a request to invoke DeleteAsrVocab API

type DeleteAsrVocabResponse ¶

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

DeleteAsrVocabResponse is the response struct for api DeleteAsrVocab

func CreateDeleteAsrVocabResponse ¶

func CreateDeleteAsrVocabResponse() (response *DeleteAsrVocabResponse)

CreateDeleteAsrVocabResponse creates a response to parse from DeleteAsrVocab response

type DeleteBusinessCategoryRequest ¶

type DeleteBusinessCategoryRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteBusinessCategoryRequest is the request struct for api DeleteBusinessCategory

func CreateDeleteBusinessCategoryRequest ¶

func CreateDeleteBusinessCategoryRequest() (request *DeleteBusinessCategoryRequest)

CreateDeleteBusinessCategoryRequest creates a request to invoke DeleteBusinessCategory API

type DeleteBusinessCategoryResponse ¶

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

DeleteBusinessCategoryResponse is the response struct for api DeleteBusinessCategory

func CreateDeleteBusinessCategoryResponse ¶

func CreateDeleteBusinessCategoryResponse() (response *DeleteBusinessCategoryResponse)

CreateDeleteBusinessCategoryResponse creates a response to parse from DeleteBusinessCategory response

type DeleteCustomizationConfigRequest ¶

type DeleteCustomizationConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteCustomizationConfigRequest is the request struct for api DeleteCustomizationConfig

func CreateDeleteCustomizationConfigRequest ¶

func CreateDeleteCustomizationConfigRequest() (request *DeleteCustomizationConfigRequest)

CreateDeleteCustomizationConfigRequest creates a request to invoke DeleteCustomizationConfig API

type DeleteCustomizationConfigResponse ¶

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

DeleteCustomizationConfigResponse is the response struct for api DeleteCustomizationConfig

func CreateDeleteCustomizationConfigResponse ¶

func CreateDeleteCustomizationConfigResponse() (response *DeleteCustomizationConfigResponse)

CreateDeleteCustomizationConfigResponse creates a response to parse from DeleteCustomizationConfig response

type DeleteDataSetRequest ¶

type DeleteDataSetRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

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
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteDataSetResponse is the response struct for api DeleteDataSet

func CreateDeleteDataSetResponse ¶

func CreateDeleteDataSetResponse() (response *DeleteDataSetResponse)

CreateDeleteDataSetResponse creates a response to parse from DeleteDataSet response

type DeletePrecisionTaskRequest ¶

type DeletePrecisionTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeletePrecisionTaskRequest is the request struct for api DeletePrecisionTask

func CreateDeletePrecisionTaskRequest ¶

func CreateDeletePrecisionTaskRequest() (request *DeletePrecisionTaskRequest)

CreateDeletePrecisionTaskRequest creates a request to invoke DeletePrecisionTask API

type DeletePrecisionTaskResponse ¶

type DeletePrecisionTaskResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeletePrecisionTaskResponse is the response struct for api DeletePrecisionTask

func CreateDeletePrecisionTaskResponse ¶

func CreateDeletePrecisionTaskResponse() (response *DeletePrecisionTaskResponse)

CreateDeletePrecisionTaskResponse creates a response to parse from DeletePrecisionTask response

type DeleteScoreForApiRequest ¶

type DeleteScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteScoreForApiRequest is the request struct for api DeleteScoreForApi

func CreateDeleteScoreForApiRequest ¶

func CreateDeleteScoreForApiRequest() (request *DeleteScoreForApiRequest)

CreateDeleteScoreForApiRequest creates a request to invoke DeleteScoreForApi API

type DeleteScoreForApiResponse ¶

type DeleteScoreForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteScoreForApiResponse is the response struct for api DeleteScoreForApi

func CreateDeleteScoreForApiResponse ¶

func CreateDeleteScoreForApiResponse() (response *DeleteScoreForApiResponse)

CreateDeleteScoreForApiResponse creates a response to parse from DeleteScoreForApi response

type DeleteSkillGroupConfigRequest ¶

type DeleteSkillGroupConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteSkillGroupConfigRequest is the request struct for api DeleteSkillGroupConfig

func CreateDeleteSkillGroupConfigRequest ¶

func CreateDeleteSkillGroupConfigRequest() (request *DeleteSkillGroupConfigRequest)

CreateDeleteSkillGroupConfigRequest creates a request to invoke DeleteSkillGroupConfig API

type DeleteSkillGroupConfigResponse ¶

type DeleteSkillGroupConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteSkillGroupConfigResponse is the response struct for api DeleteSkillGroupConfig

func CreateDeleteSkillGroupConfigResponse ¶

func CreateDeleteSkillGroupConfigResponse() (response *DeleteSkillGroupConfigResponse)

CreateDeleteSkillGroupConfigResponse creates a response to parse from DeleteSkillGroupConfig response

type DeleteSubScoreForApiRequest ¶

type DeleteSubScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteSubScoreForApiRequest is the request struct for api DeleteSubScoreForApi

func CreateDeleteSubScoreForApiRequest ¶

func CreateDeleteSubScoreForApiRequest() (request *DeleteSubScoreForApiRequest)

CreateDeleteSubScoreForApiRequest creates a request to invoke DeleteSubScoreForApi API

type DeleteSubScoreForApiResponse ¶

type DeleteSubScoreForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteSubScoreForApiResponse is the response struct for api DeleteSubScoreForApi

func CreateDeleteSubScoreForApiResponse ¶

func CreateDeleteSubScoreForApiResponse() (response *DeleteSubScoreForApiResponse)

CreateDeleteSubScoreForApiResponse creates a response to parse from DeleteSubScoreForApi response

type DeleteTaskAssignRuleRequest ¶

type DeleteTaskAssignRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteTaskAssignRuleRequest is the request struct for api DeleteTaskAssignRule

func CreateDeleteTaskAssignRuleRequest ¶

func CreateDeleteTaskAssignRuleRequest() (request *DeleteTaskAssignRuleRequest)

CreateDeleteTaskAssignRuleRequest creates a request to invoke DeleteTaskAssignRule API

type DeleteTaskAssignRuleResponse ¶

type DeleteTaskAssignRuleResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteTaskAssignRuleResponse is the response struct for api DeleteTaskAssignRule

func CreateDeleteTaskAssignRuleResponse ¶

func CreateDeleteTaskAssignRuleResponse() (response *DeleteTaskAssignRuleResponse)

CreateDeleteTaskAssignRuleResponse creates a response to parse from DeleteTaskAssignRule response

type DeleteUserRequest ¶

type DeleteUserRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteUserRequest is the request struct for api DeleteUser

func CreateDeleteUserRequest ¶

func CreateDeleteUserRequest() (request *DeleteUserRequest)

CreateDeleteUserRequest creates a request to invoke DeleteUser API

type DeleteUserResponse ¶

type DeleteUserResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteUserResponse is the response struct for api DeleteUser

func CreateDeleteUserResponse ¶

func CreateDeleteUserResponse() (response *DeleteUserResponse)

CreateDeleteUserResponse creates a response to parse from DeleteUser response

type DeleteWarningConfigRequest ¶

type DeleteWarningConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

DeleteWarningConfigRequest is the request struct for api DeleteWarningConfig

func CreateDeleteWarningConfigRequest ¶

func CreateDeleteWarningConfigRequest() (request *DeleteWarningConfigRequest)

CreateDeleteWarningConfigRequest creates a request to invoke DeleteWarningConfig API

type DeleteWarningConfigResponse ¶

type DeleteWarningConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

DeleteWarningConfigResponse is the response struct for api DeleteWarningConfig

func CreateDeleteWarningConfigResponse ¶

func CreateDeleteWarningConfigResponse() (response *DeleteWarningConfigResponse)

CreateDeleteWarningConfigResponse creates a response to parse from DeleteWarningConfig response

type Delta ¶

type Delta struct {
	Type   string `json:"Type" xml:"Type"`
	Source Source `json:"Source" xml:"Source"`
	Target Target `json:"Target" xml:"Target"`
}

Delta is a nested struct in qualitycheck response

type Deltas ¶

type Deltas struct {
	Delta []Delta `json:"Delta" xml:"Delta"`
}

Deltas is a nested struct in qualitycheck response

type Dialogue ¶

type Dialogue struct {
	End             int64  `json:"End" xml:"End"`
	IncorrectWords  int    `json:"IncorrectWords" xml:"IncorrectWords"`
	HourMinSec      string `json:"HourMinSec" xml:"HourMinSec"`
	SourceRole      string `json:"SourceRole" xml:"SourceRole"`
	SilenceDuration int    `json:"SilenceDuration" xml:"SilenceDuration"`
	EmotionValue    int    `json:"EmotionValue" xml:"EmotionValue"`
	Words           string `json:"Words" xml:"Words"`
	Identity        string `json:"Identity" xml:"Identity"`
	Role            string `json:"Role" xml:"Role"`
	SpeechRate      int    `json:"SpeechRate" xml:"SpeechRate"`
	SourceWords     string `json:"SourceWords" xml:"SourceWords"`
	BeginTime       string `json:"BeginTime" xml:"BeginTime"`
	Begin           int64  `json:"Begin" xml:"Begin"`
	Deltas          Deltas `json:"Deltas" xml:"Deltas"`
}

Dialogue is a nested struct in qualitycheck response

type DialogueParam ¶

type DialogueParam struct {
	EndTime    string `json:"EndTime" xml:"EndTime"`
	DialogueId int64  `json:"DialogueId" xml:"DialogueId"`
	EndIndex   int    `json:"EndIndex" xml:"EndIndex"`
	StartTime  string `json:"StartTime" xml:"StartTime"`
	SourceType int    `json:"SourceType" xml:"SourceType"`
	StartIndex int    `json:"StartIndex" xml:"StartIndex"`
	Role       int    `json:"Role" xml:"Role"`
	DataSetIds string `json:"DataSetIds" xml:"DataSetIds"`
}

DialogueParam is a nested struct in qualitycheck response

type DialoguesInGetNextResultToVerify ¶

type DialoguesInGetNextResultToVerify struct {
	Dialogue []Dialogue `json:"Dialogue" xml:"Dialogue"`
}

DialoguesInGetNextResultToVerify is a nested struct in qualitycheck response

type DialoguesInGetResultToReview ¶

type DialoguesInGetResultToReview struct {
	Dialogue []Dialogue `json:"Dialogue" xml:"Dialogue"`
}

DialoguesInGetResultToReview is a nested struct in qualitycheck response

type EditThesaurusForApiRequest ¶

type EditThesaurusForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

EditThesaurusForApiRequest is the request struct for api EditThesaurusForApi

func CreateEditThesaurusForApiRequest ¶

func CreateEditThesaurusForApiRequest() (request *EditThesaurusForApiRequest)

CreateEditThesaurusForApiRequest creates a request to invoke EditThesaurusForApi API

type EditThesaurusForApiResponse ¶

type EditThesaurusForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      int64  `json:"Data" xml:"Data"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

EditThesaurusForApiResponse is the response struct for api EditThesaurusForApi

func CreateEditThesaurusForApiResponse ¶

func CreateEditThesaurusForApiResponse() (response *EditThesaurusForApiResponse)

CreateEditThesaurusForApiResponse creates a response to parse from EditThesaurusForApi response

type Excludes ¶

type Excludes struct {
	Excludes []string `json:"Excludes" xml:"Excludes"`
}

Excludes is a nested struct in qualitycheck response

type GetAsrVocabRequest ¶

type GetAsrVocabRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetAsrVocabRequest is the request struct for api GetAsrVocab

func CreateGetAsrVocabRequest ¶

func CreateGetAsrVocabRequest() (request *GetAsrVocabRequest)

CreateGetAsrVocabRequest creates a request to invoke GetAsrVocab API

type GetAsrVocabResponse ¶

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

GetAsrVocabResponse is the response struct for api GetAsrVocab

func CreateGetAsrVocabResponse ¶

func CreateGetAsrVocabResponse() (response *GetAsrVocabResponse)

CreateGetAsrVocabResponse creates a response to parse from GetAsrVocab response

type GetBusinessCategoryListRequest ¶

type GetBusinessCategoryListRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetBusinessCategoryListRequest is the request struct for api GetBusinessCategoryList

func CreateGetBusinessCategoryListRequest ¶

func CreateGetBusinessCategoryListRequest() (request *GetBusinessCategoryListRequest)

CreateGetBusinessCategoryListRequest creates a request to invoke GetBusinessCategoryList API

type GetBusinessCategoryListResponse ¶

type GetBusinessCategoryListResponse struct {
	*responses.BaseResponse
	Code      string                        `json:"Code" xml:"Code"`
	Message   string                        `json:"Message" xml:"Message"`
	RequestId string                        `json:"RequestId" xml:"RequestId"`
	Success   bool                          `json:"Success" xml:"Success"`
	Data      DataInGetBusinessCategoryList `json:"Data" xml:"Data"`
}

GetBusinessCategoryListResponse is the response struct for api GetBusinessCategoryList

func CreateGetBusinessCategoryListResponse ¶

func CreateGetBusinessCategoryListResponse() (response *GetBusinessCategoryListResponse)

CreateGetBusinessCategoryListResponse creates a response to parse from GetBusinessCategoryList response

type GetCustomizationConfigListRequest ¶

type GetCustomizationConfigListRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetCustomizationConfigListRequest is the request struct for api GetCustomizationConfigList

func CreateGetCustomizationConfigListRequest ¶

func CreateGetCustomizationConfigListRequest() (request *GetCustomizationConfigListRequest)

CreateGetCustomizationConfigListRequest creates a request to invoke GetCustomizationConfigList API

type GetCustomizationConfigListResponse ¶

type GetCustomizationConfigListResponse struct {
	*responses.BaseResponse
	Code      string                           `json:"Code" xml:"Code"`
	Message   string                           `json:"Message" xml:"Message"`
	RequestId string                           `json:"RequestId" xml:"RequestId"`
	Success   bool                             `json:"Success" xml:"Success"`
	Data      DataInGetCustomizationConfigList `json:"Data" xml:"Data"`
}

GetCustomizationConfigListResponse is the response struct for api GetCustomizationConfigList

func CreateGetCustomizationConfigListResponse ¶

func CreateGetCustomizationConfigListResponse() (response *GetCustomizationConfigListResponse)

CreateGetCustomizationConfigListResponse creates a response to parse from GetCustomizationConfigList response

type GetHitResultRequest ¶

type GetHitResultRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetHitResultRequest is the request struct for api GetHitResult

func CreateGetHitResultRequest ¶

func CreateGetHitResultRequest() (request *GetHitResultRequest)

CreateGetHitResultRequest creates a request to invoke GetHitResult API

type GetHitResultResponse ¶

type GetHitResultResponse struct {
	*responses.BaseResponse
	RequestId  string             `json:"RequestId" xml:"RequestId"`
	Success    bool               `json:"Success" xml:"Success"`
	Code       string             `json:"Code" xml:"Code"`
	Message    string             `json:"Message" xml:"Message"`
	PageNumber int                `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                `json:"PageSize" xml:"PageSize"`
	Count      int                `json:"Count" xml:"Count"`
	Data       DataInGetHitResult `json:"Data" xml:"Data"`
}

GetHitResultResponse is the response struct for api GetHitResult

func CreateGetHitResultResponse ¶

func CreateGetHitResultResponse() (response *GetHitResultResponse)

CreateGetHitResultResponse creates a response to parse from GetHitResult response

type GetNextResultToVerifyRequest ¶

type GetNextResultToVerifyRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetNextResultToVerifyRequest is the request struct for api GetNextResultToVerify

func CreateGetNextResultToVerifyRequest ¶

func CreateGetNextResultToVerifyRequest() (request *GetNextResultToVerifyRequest)

CreateGetNextResultToVerifyRequest creates a request to invoke GetNextResultToVerify API

type GetNextResultToVerifyResponse ¶

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

GetNextResultToVerifyResponse is the response struct for api GetNextResultToVerify

func CreateGetNextResultToVerifyResponse ¶

func CreateGetNextResultToVerifyResponse() (response *GetNextResultToVerifyResponse)

CreateGetNextResultToVerifyResponse creates a response to parse from GetNextResultToVerify response

type GetPrecisionTaskRequest ¶

type GetPrecisionTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetPrecisionTaskRequest is the request struct for api GetPrecisionTask

func CreateGetPrecisionTaskRequest ¶

func CreateGetPrecisionTaskRequest() (request *GetPrecisionTaskRequest)

CreateGetPrecisionTaskRequest creates a request to invoke GetPrecisionTask API

type GetPrecisionTaskResponse ¶

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

GetPrecisionTaskResponse is the response struct for api GetPrecisionTask

func CreateGetPrecisionTaskResponse ¶

func CreateGetPrecisionTaskResponse() (response *GetPrecisionTaskResponse)

CreateGetPrecisionTaskResponse creates a response to parse from GetPrecisionTask response

type GetResultCallbackRequest ¶

type GetResultCallbackRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetResultCallbackRequest is the request struct for api GetResultCallback

func CreateGetResultCallbackRequest ¶

func CreateGetResultCallbackRequest() (request *GetResultCallbackRequest)

CreateGetResultCallbackRequest creates a request to invoke GetResultCallback API

type GetResultCallbackResponse ¶

type GetResultCallbackResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

GetResultCallbackResponse is the response struct for api GetResultCallback

func CreateGetResultCallbackResponse ¶

func CreateGetResultCallbackResponse() (response *GetResultCallbackResponse)

CreateGetResultCallbackResponse creates a response to parse from GetResultCallback response

type GetResultRequest ¶

type GetResultRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetResultRequest is the request struct for api GetResult

func CreateGetResultRequest ¶

func CreateGetResultRequest() (request *GetResultRequest)

CreateGetResultRequest creates a request to invoke GetResult API

type GetResultResponse ¶

type GetResultResponse struct {
	*responses.BaseResponse
	RequestId     string          `json:"RequestId" xml:"RequestId"`
	Success       bool            `json:"Success" xml:"Success"`
	ResultCountId string          `json:"ResultCountId" xml:"ResultCountId"`
	Code          string          `json:"Code" xml:"Code"`
	Message       string          `json:"Message" xml:"Message"`
	PageNumber    int             `json:"PageNumber" xml:"PageNumber"`
	PageSize      int             `json:"PageSize" xml:"PageSize"`
	Count         int             `json:"Count" xml:"Count"`
	Data          DataInGetResult `json:"Data" xml:"Data"`
}

GetResultResponse is the response struct for api GetResult

func CreateGetResultResponse ¶

func CreateGetResultResponse() (response *GetResultResponse)

CreateGetResultResponse creates a response to parse from GetResult response

type GetResultToReviewRequest ¶

type GetResultToReviewRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetResultToReviewRequest is the request struct for api GetResultToReview

func CreateGetResultToReviewRequest ¶

func CreateGetResultToReviewRequest() (request *GetResultToReviewRequest)

CreateGetResultToReviewRequest creates a request to invoke GetResultToReview API

type GetResultToReviewResponse ¶

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

GetResultToReviewResponse is the response struct for api GetResultToReview

func CreateGetResultToReviewResponse ¶

func CreateGetResultToReviewResponse() (response *GetResultToReviewResponse)

CreateGetResultToReviewResponse creates a response to parse from GetResultToReview response

type GetRuleCategoryRequest ¶

type GetRuleCategoryRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetRuleCategoryRequest is the request struct for api GetRuleCategory

func CreateGetRuleCategoryRequest ¶

func CreateGetRuleCategoryRequest() (request *GetRuleCategoryRequest)

CreateGetRuleCategoryRequest creates a request to invoke GetRuleCategory API

type GetRuleCategoryResponse ¶

type GetRuleCategoryResponse struct {
	*responses.BaseResponse
	Code      string                `json:"Code" xml:"Code"`
	Message   string                `json:"Message" xml:"Message"`
	RequestId string                `json:"RequestId" xml:"RequestId"`
	Success   bool                  `json:"Success" xml:"Success"`
	Data      DataInGetRuleCategory `json:"Data" xml:"Data"`
}

GetRuleCategoryResponse is the response struct for api GetRuleCategory

func CreateGetRuleCategoryResponse ¶

func CreateGetRuleCategoryResponse() (response *GetRuleCategoryResponse)

CreateGetRuleCategoryResponse creates a response to parse from GetRuleCategory response

type GetRuleDetailRequest ¶

type GetRuleDetailRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetRuleDetailRequest is the request struct for api GetRuleDetail

func CreateGetRuleDetailRequest ¶

func CreateGetRuleDetailRequest() (request *GetRuleDetailRequest)

CreateGetRuleDetailRequest creates a request to invoke GetRuleDetail API

type GetRuleDetailResponse ¶

type GetRuleDetailResponse struct {
	*responses.BaseResponse
	Code      string              `json:"Code" xml:"Code"`
	Message   string              `json:"Message" xml:"Message"`
	RequestId string              `json:"RequestId" xml:"RequestId"`
	Success   bool                `json:"Success" xml:"Success"`
	Data      DataInGetRuleDetail `json:"Data" xml:"Data"`
}

GetRuleDetailResponse is the response struct for api GetRuleDetail

func CreateGetRuleDetailResponse ¶

func CreateGetRuleDetailResponse() (response *GetRuleDetailResponse)

CreateGetRuleDetailResponse creates a response to parse from GetRuleDetail response

type GetRuleRequest ¶

type GetRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetRuleRequest is the request struct for api GetRule

func CreateGetRuleRequest ¶

func CreateGetRuleRequest() (request *GetRuleRequest)

CreateGetRuleRequest creates a request to invoke GetRule API

type GetRuleResponse ¶

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

GetRuleResponse is the response struct for api GetRule

func CreateGetRuleResponse ¶

func CreateGetRuleResponse() (response *GetRuleResponse)

CreateGetRuleResponse creates a response to parse from GetRule response

type GetScoreInfoRequest ¶

type GetScoreInfoRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetScoreInfoRequest is the request struct for api GetScoreInfo

func CreateGetScoreInfoRequest ¶

func CreateGetScoreInfoRequest() (request *GetScoreInfoRequest)

CreateGetScoreInfoRequest creates a request to invoke GetScoreInfo API

type GetScoreInfoResponse ¶

type GetScoreInfoResponse struct {
	*responses.BaseResponse
	Code      string             `json:"Code" xml:"Code"`
	Message   string             `json:"Message" xml:"Message"`
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Success   bool               `json:"Success" xml:"Success"`
	Data      DataInGetScoreInfo `json:"Data" xml:"Data"`
}

GetScoreInfoResponse is the response struct for api GetScoreInfo

func CreateGetScoreInfoResponse ¶

func CreateGetScoreInfoResponse() (response *GetScoreInfoResponse)

CreateGetScoreInfoResponse creates a response to parse from GetScoreInfo response

type GetSkillGroupConfigRequest ¶

type GetSkillGroupConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetSkillGroupConfigRequest is the request struct for api GetSkillGroupConfig

func CreateGetSkillGroupConfigRequest ¶

func CreateGetSkillGroupConfigRequest() (request *GetSkillGroupConfigRequest)

CreateGetSkillGroupConfigRequest creates a request to invoke GetSkillGroupConfig API

type GetSkillGroupConfigResponse ¶

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

GetSkillGroupConfigResponse is the response struct for api GetSkillGroupConfig

func CreateGetSkillGroupConfigResponse ¶

func CreateGetSkillGroupConfigResponse() (response *GetSkillGroupConfigResponse)

CreateGetSkillGroupConfigResponse creates a response to parse from GetSkillGroupConfig response

type GetSyncResultRequest ¶

type GetSyncResultRequest struct {
	*requests.RpcRequest
	JsonStr string `position:"Query" name:"JsonStr"`
}

GetSyncResultRequest is the request struct for api GetSyncResult

func CreateGetSyncResultRequest ¶

func CreateGetSyncResultRequest() (request *GetSyncResultRequest)

CreateGetSyncResultRequest creates a request to invoke GetSyncResult API

type GetSyncResultResponse ¶

type GetSyncResultResponse struct {
	*responses.BaseResponse
	RequestId     string                      `json:"RequestId" xml:"RequestId"`
	Success       bool                        `json:"Success" xml:"Success"`
	ResultCountId string                      `json:"ResultCountId" xml:"ResultCountId"`
	Code          string                      `json:"Code" xml:"Code"`
	Message       string                      `json:"Message" xml:"Message"`
	PageNumber    int                         `json:"PageNumber" xml:"PageNumber"`
	PageSize      int                         `json:"PageSize" xml:"PageSize"`
	Count         int                         `json:"Count" xml:"Count"`
	Data          []ResultInfoInGetSyncResult `json:"Data" xml:"Data"`
}

GetSyncResultResponse is the response struct for api GetSyncResult

func CreateGetSyncResultResponse ¶

func CreateGetSyncResultResponse() (response *GetSyncResultResponse)

CreateGetSyncResultResponse creates a response to parse from GetSyncResult response

type GetThesaurusBySynonymForApiRequest ¶

type GetThesaurusBySynonymForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

GetThesaurusBySynonymForApiRequest is the request struct for api GetThesaurusBySynonymForApi

func CreateGetThesaurusBySynonymForApiRequest ¶

func CreateGetThesaurusBySynonymForApiRequest() (request *GetThesaurusBySynonymForApiRequest)

CreateGetThesaurusBySynonymForApiRequest creates a request to invoke GetThesaurusBySynonymForApi API

type GetThesaurusBySynonymForApiResponse ¶

type GetThesaurusBySynonymForApiResponse struct {
	*responses.BaseResponse
	Code      string                            `json:"Code" xml:"Code"`
	Message   string                            `json:"Message" xml:"Message"`
	RequestId string                            `json:"RequestId" xml:"RequestId"`
	Success   bool                              `json:"Success" xml:"Success"`
	Data      DataInGetThesaurusBySynonymForApi `json:"Data" xml:"Data"`
}

GetThesaurusBySynonymForApiResponse is the response struct for api GetThesaurusBySynonymForApi

func CreateGetThesaurusBySynonymForApiResponse ¶

func CreateGetThesaurusBySynonymForApiResponse() (response *GetThesaurusBySynonymForApiResponse)

CreateGetThesaurusBySynonymForApiResponse creates a response to parse from GetThesaurusBySynonymForApi response

type HandScoreIdList ¶

type HandScoreIdList struct {
	HandScoreIdList []string `json:"HandScoreIdList" xml:"HandScoreIdList"`
}

HandScoreIdList is a nested struct in qualitycheck response

type HandScoreInfoList ¶

type HandScoreInfoList struct {
	ScorePo []ScorePo `json:"ScorePo" xml:"ScorePo"`
}

HandScoreInfoList is a nested struct in qualitycheck response

type HandleComplaintRequest ¶

type HandleComplaintRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

HandleComplaintRequest is the request struct for api HandleComplaint

func CreateHandleComplaintRequest ¶

func CreateHandleComplaintRequest() (request *HandleComplaintRequest)

CreateHandleComplaintRequest creates a request to invoke HandleComplaint API

type HandleComplaintResponse ¶

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

HandleComplaintResponse is the response struct for api HandleComplaint

func CreateHandleComplaintResponse ¶

func CreateHandleComplaintResponse() (response *HandleComplaintResponse)

CreateHandleComplaintResponse creates a response to parse from HandleComplaint response

type Hit ¶

type Hit struct {
	Cid      []string            `json:"Cid" xml:"Cid"`
	Phrase   Phrase              `json:"Phrase" xml:"Phrase"`
	KeyWords KeyWordsInGetResult `json:"KeyWords" xml:"KeyWords"`
}

Hit is a nested struct in qualitycheck response

type HitCids ¶

type HitCids struct {
	CidItem []string `json:"CidItem" xml:"CidItem"`
}

HitCids is a nested struct in qualitycheck response

type HitInGetResult ¶

type HitInGetResult struct {
	Cid      CidInGetResult      `json:"Cid" xml:"Cid"`
	Phrase   Phrase              `json:"Phrase" xml:"Phrase"`
	KeyWords KeyWordsInGetResult `json:"KeyWords" xml:"KeyWords"`
}

HitInGetResult is a nested struct in qualitycheck response

type HitInSyncQualityCheck ¶

type HitInSyncQualityCheck struct {
	ConditionHitInfo []ConditionHitInfoInSyncQualityCheck `json:"ConditionHitInfo" xml:"ConditionHitInfo"`
}

HitInSyncQualityCheck is a nested struct in qualitycheck response

type HitInUploadDataSync ¶

type HitInUploadDataSync struct {
	ConditionHitInfo []ConditionHitInfo `json:"ConditionHitInfo" xml:"ConditionHitInfo"`
}

HitInUploadDataSync is a nested struct in qualitycheck response

type HitKeyWord ¶

type HitKeyWord struct {
	To   int    `json:"To" xml:"To"`
	Val  string `json:"Val" xml:"Val"`
	Pid  int    `json:"Pid" xml:"Pid"`
	Cid  int    `json:"Cid" xml:"Cid"`
	From int    `json:"From" xml:"From"`
	Tid  string `json:"Tid" xml:"Tid"`
}

HitKeyWord is a nested struct in qualitycheck response

type HitKeyWordsInSyncQualityCheck ¶

type HitKeyWordsInSyncQualityCheck struct {
	HitKeyWord []HitKeyWord `json:"HitKeyWord" xml:"HitKeyWord"`
}

HitKeyWordsInSyncQualityCheck is a nested struct in qualitycheck response

type HitKeyWordsInUploadDataSync ¶

type HitKeyWordsInUploadDataSync struct {
	HitKeyWord []HitKeyWord `json:"HitKeyWord" xml:"HitKeyWord"`
}

HitKeyWordsInUploadDataSync is a nested struct in qualitycheck response

type HitResultInGetResult ¶

type HitResultInGetResult struct {
	HitResultItem []HitResultItemInGetResult `json:"HitResult" xml:"HitResult"`
}

HitResultInGetResult is a nested struct in qualitycheck response

type HitResultInGetSyncResult ¶

type HitResultInGetSyncResult struct {
	HitResultItem []HitResultItem `json:"HitResult" xml:"HitResult"`
}

HitResultInGetSyncResult is a nested struct in qualitycheck response

type HitResultItem ¶

type HitResultItem struct {
	Name          string          `json:"Name" xml:"Name"`
	Rid           string          `json:"Rid" xml:"Rid"`
	SchemeId      int64           `json:"SchemeId" xml:"SchemeId"`
	ReviewResult  int             `json:"ReviewResult" xml:"ReviewResult"`
	Type          string          `json:"Type" xml:"Type"`
	SchemeVersion int64           `json:"SchemeVersion" xml:"SchemeVersion"`
	Hits          HitsInGetResult `json:"Hits" xml:"Hits"`
}

HitResultItem is a nested struct in qualitycheck response

type HitResultItemInGetResult ¶

type HitResultItemInGetResult struct {
	Type          string          `json:"Type" xml:"Type"`
	ReviewResult  int             `json:"ReviewResult" xml:"ReviewResult"`
	Name          string          `json:"Name" xml:"Name"`
	Rid           string          `json:"Rid" xml:"Rid"`
	SchemeId      int64           `json:"SchemeId" xml:"SchemeId"`
	SchemeVersion int64           `json:"SchemeVersion" xml:"SchemeVersion"`
	Hits          HitsInGetResult `json:"Hits" xml:"Hits"`
}

HitResultItemInGetResult is a nested struct in qualitycheck response

type HitRuleReviewInfo ¶

type HitRuleReviewInfo struct {
	RuleScoreType        int                                  `json:"RuleScoreType" xml:"RuleScoreType"`
	RuleType             int                                  `json:"RuleType" xml:"RuleType"`
	ScoreSubName         string                               `json:"ScoreSubName" xml:"ScoreSubName"`
	ScoreNum             int                                  `json:"ScoreNum" xml:"ScoreNum"`
	AutoReview           int                                  `json:"AutoReview" xml:"AutoReview"`
	ScoreSubId           int64                                `json:"ScoreSubId" xml:"ScoreSubId"`
	Complainable         bool                                 `json:"Complainable" xml:"Complainable"`
	TotalNumber          int                                  `json:"TotalNumber" xml:"TotalNumber"`
	ScoreId              int64                                `json:"ScoreId" xml:"ScoreId"`
	RuleName             string                               `json:"RuleName" xml:"RuleName"`
	Rid                  int64                                `json:"Rid" xml:"Rid"`
	ReviewInfo           ReviewInfo                           `json:"ReviewInfo" xml:"ReviewInfo"`
	ConditionHitInfoList ConditionHitInfoList                 `json:"ConditionHitInfoList" xml:"ConditionHitInfoList"`
	ComplainHistories    ComplainHistoriesInGetResultToReview `json:"ComplainHistories" xml:"ComplainHistories"`
}

HitRuleReviewInfo is a nested struct in qualitycheck response

type HitRuleReviewInfoList ¶

type HitRuleReviewInfoList struct {
	HitRuleReviewInfo []HitRuleReviewInfo `json:"HitRuleReviewInfo" xml:"HitRuleReviewInfo"`
}

HitRuleReviewInfoList is a nested struct in qualitycheck response

type HitScore ¶

type HitScore struct {
	HitScoreItem []HitScoreItem `json:"HitScore" xml:"HitScore"`
}

HitScore is a nested struct in qualitycheck response

type HitScoreItem ¶

type HitScoreItem struct {
	ScoreName   string `json:"ScoreName" xml:"ScoreName"`
	ScoreNumber string `json:"ScoreNumber" xml:"ScoreNumber"`
	ScoreId     string `json:"ScoreId" xml:"ScoreId"`
	RuleId      string `json:"RuleId" xml:"RuleId"`
}

HitScoreItem is a nested struct in qualitycheck response

type HitsInGetResult ¶

type HitsInGetResult struct {
	Hit []HitInGetResult `json:"Hit" xml:"Hit"`
}

HitsInGetResult is a nested struct in qualitycheck response

type HitsInGetSyncResult ¶

type HitsInGetSyncResult struct {
	Hit []Hit `json:"Hit" xml:"Hit"`
}

HitsInGetSyncResult is a nested struct in qualitycheck response

type HotWordsTaskPo ¶

type HotWordsTaskPo struct {
	EndTime           string        `json:"EndTime" xml:"EndTime"`
	Type              int           `json:"Type" xml:"Type"`
	Status            int           `json:"Status" xml:"Status"`
	TimeInterval      int           `json:"TimeInterval" xml:"TimeInterval"`
	StartTime         string        `json:"StartTime" xml:"StartTime"`
	TaskConfigId      int64         `json:"TaskConfigId" xml:"TaskConfigId"`
	Message           string        `json:"Message" xml:"Message"`
	InstanceStatus    int           `json:"InstanceStatus" xml:"InstanceStatus"`
	LastExecutionTime string        `json:"LastExecutionTime" xml:"LastExecutionTime"`
	Name              string        `json:"Name" xml:"Name"`
	TimeUnit          int           `json:"TimeUnit" xml:"TimeUnit"`
	DialogueParam     DialogueParam `json:"DialogueParam" xml:"DialogueParam"`
	WordsParam        WordsParam    `json:"WordsParam" xml:"WordsParam"`
}

HotWordsTaskPo is a nested struct in qualitycheck response

type InsertScoreForApiRequest ¶

type InsertScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

InsertScoreForApiRequest is the request struct for api InsertScoreForApi

func CreateInsertScoreForApiRequest ¶

func CreateInsertScoreForApiRequest() (request *InsertScoreForApiRequest)

CreateInsertScoreForApiRequest creates a request to invoke InsertScoreForApi API

type InsertScoreForApiResponse ¶

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

InsertScoreForApiResponse is the response struct for api InsertScoreForApi

func CreateInsertScoreForApiResponse ¶

func CreateInsertScoreForApiResponse() (response *InsertScoreForApiResponse)

CreateInsertScoreForApiResponse creates a response to parse from InsertScoreForApi response

type InsertSubScoreForApiRequest ¶

type InsertSubScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

InsertSubScoreForApiRequest is the request struct for api InsertSubScoreForApi

func CreateInsertSubScoreForApiRequest ¶

func CreateInsertSubScoreForApiRequest() (request *InsertSubScoreForApiRequest)

CreateInsertSubScoreForApiRequest creates a request to invoke InsertSubScoreForApi API

type InsertSubScoreForApiResponse ¶

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

InsertSubScoreForApiResponse is the response struct for api InsertSubScoreForApi

func CreateInsertSubScoreForApiResponse ¶

func CreateInsertSubScoreForApiResponse() (response *InsertSubScoreForApiResponse)

CreateInsertSubScoreForApiResponse creates a response to parse from InsertSubScoreForApi response

type InvalidRuleRequest ¶

type InvalidRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

InvalidRuleRequest is the request struct for api InvalidRule

func CreateInvalidRuleRequest ¶

func CreateInvalidRuleRequest() (request *InvalidRuleRequest)

CreateInvalidRuleRequest creates a request to invoke InvalidRule API

type InvalidRuleResponse ¶

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

InvalidRuleResponse is the response struct for api InvalidRule

func CreateInvalidRuleResponse ¶

func CreateInvalidRuleResponse() (response *InvalidRuleResponse)

CreateInvalidRuleResponse creates a response to parse from InvalidRule response

type KeyWord ¶

type KeyWord struct {
	Cid           string `json:"Cid" xml:"Cid"`
	To            int    `json:"To" xml:"To"`
	Val           string `json:"Val" xml:"Val"`
	Pid           int    `json:"Pid" xml:"Pid"`
	CustomizeCode string `json:"CustomizeCode" xml:"CustomizeCode"`
	From          int    `json:"From" xml:"From"`
	Tid           string `json:"Tid" xml:"Tid"`
}

KeyWord is a nested struct in qualitycheck response

type KeyWordsInGetResult ¶

type KeyWordsInGetResult struct {
	KeyWord []KeyWord `json:"KeyWord" xml:"KeyWord"`
}

KeyWordsInGetResult is a nested struct in qualitycheck response

type KeyWordsInGetResultToReview ¶

type KeyWordsInGetResultToReview struct {
	KeyWord []KeyWord `json:"KeyWord" xml:"KeyWord"`
}

KeyWordsInGetResultToReview is a nested struct in qualitycheck response

type KeyWordsInGetSyncResult ¶

type KeyWordsInGetSyncResult struct {
	KeyWord []KeyWord `json:"KeyWord" xml:"KeyWord"`
}

KeyWordsInGetSyncResult is a nested struct in qualitycheck response

type LineInGetNextResultToVerify ¶

type LineInGetNextResultToVerify struct {
	Line []string `json:"Line" xml:"Line"`
}

LineInGetNextResultToVerify is a nested struct in qualitycheck response

type LineInVerifySentence ¶

type LineInVerifySentence struct {
	Line []string `json:"Line" xml:"Line"`
}

LineInVerifySentence is a nested struct in qualitycheck response

type ListAsrVocabRequest ¶

type ListAsrVocabRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListAsrVocabRequest is the request struct for api ListAsrVocab

func CreateListAsrVocabRequest ¶

func CreateListAsrVocabRequest() (request *ListAsrVocabRequest)

CreateListAsrVocabRequest creates a request to invoke ListAsrVocab API

type ListAsrVocabResponse ¶

type ListAsrVocabResponse struct {
	*responses.BaseResponse
	Code      string             `json:"Code" xml:"Code"`
	Message   string             `json:"Message" xml:"Message"`
	RequestId string             `json:"RequestId" xml:"RequestId"`
	Success   bool               `json:"Success" xml:"Success"`
	Data      DataInListAsrVocab `json:"Data" xml:"Data"`
}

ListAsrVocabResponse is the response struct for api ListAsrVocab

func CreateListAsrVocabResponse ¶

func CreateListAsrVocabResponse() (response *ListAsrVocabResponse)

CreateListAsrVocabResponse creates a response to parse from ListAsrVocab response

type ListBusinessSpacesRequest ¶

type ListBusinessSpacesRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListBusinessSpacesRequest is the request struct for api ListBusinessSpaces

func CreateListBusinessSpacesRequest ¶

func CreateListBusinessSpacesRequest() (request *ListBusinessSpacesRequest)

CreateListBusinessSpacesRequest creates a request to invoke ListBusinessSpaces API

type ListBusinessSpacesResponse ¶

type ListBusinessSpacesResponse struct {
	*responses.BaseResponse
	CurrentPage int        `json:"CurrentPage" xml:"CurrentPage"`
	PageSize    int        `json:"PageSize" xml:"PageSize"`
	PageNumber  int        `json:"PageNumber" xml:"PageNumber"`
	RequestId   string     `json:"RequestId" xml:"RequestId"`
	Success     bool       `json:"Success" xml:"Success"`
	Code        string     `json:"Code" xml:"Code"`
	Message     string     `json:"Message" xml:"Message"`
	Data        []DataItem `json:"Data" xml:"Data"`
}

ListBusinessSpacesResponse is the response struct for api ListBusinessSpaces

func CreateListBusinessSpacesResponse ¶

func CreateListBusinessSpacesResponse() (response *ListBusinessSpacesResponse)

CreateListBusinessSpacesResponse creates a response to parse from ListBusinessSpaces response

type ListHotWordsTasksRequest ¶

type ListHotWordsTasksRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListHotWordsTasksRequest is the request struct for api ListHotWordsTasks

func CreateListHotWordsTasksRequest ¶

func CreateListHotWordsTasksRequest() (request *ListHotWordsTasksRequest)

CreateListHotWordsTasksRequest creates a request to invoke ListHotWordsTasks API

type ListHotWordsTasksResponse ¶

type ListHotWordsTasksResponse struct {
	*responses.BaseResponse
	RequestId  string                  `json:"RequestId" xml:"RequestId"`
	Success    bool                    `json:"Success" xml:"Success"`
	Code       string                  `json:"Code" xml:"Code"`
	Message    string                  `json:"Message" xml:"Message"`
	PageNumber int                     `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                     `json:"PageSize" xml:"PageSize"`
	Count      int                     `json:"Count" xml:"Count"`
	Data       DataInListHotWordsTasks `json:"Data" xml:"Data"`
}

ListHotWordsTasksResponse is the response struct for api ListHotWordsTasks

func CreateListHotWordsTasksResponse ¶

func CreateListHotWordsTasksResponse() (response *ListHotWordsTasksResponse)

CreateListHotWordsTasksResponse creates a response to parse from ListHotWordsTasks response

type ListPrecisionTaskRequest ¶

type ListPrecisionTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListPrecisionTaskRequest is the request struct for api ListPrecisionTask

func CreateListPrecisionTaskRequest ¶

func CreateListPrecisionTaskRequest() (request *ListPrecisionTaskRequest)

CreateListPrecisionTaskRequest creates a request to invoke ListPrecisionTask API

type ListPrecisionTaskResponse ¶

type ListPrecisionTaskResponse struct {
	*responses.BaseResponse
	RequestId  string                  `json:"RequestId" xml:"RequestId"`
	Success    bool                    `json:"Success" xml:"Success"`
	Code       string                  `json:"Code" xml:"Code"`
	Message    string                  `json:"Message" xml:"Message"`
	PageNumber int                     `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                     `json:"PageSize" xml:"PageSize"`
	Count      int                     `json:"Count" xml:"Count"`
	Data       DataInListPrecisionTask `json:"Data" xml:"Data"`
}

ListPrecisionTaskResponse is the response struct for api ListPrecisionTask

func CreateListPrecisionTaskResponse ¶

func CreateListPrecisionTaskResponse() (response *ListPrecisionTaskResponse)

CreateListPrecisionTaskResponse creates a response to parse from ListPrecisionTask response

type ListQualityCheckSchemeRequest ¶

type ListQualityCheckSchemeRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListQualityCheckSchemeRequest is the request struct for api ListQualityCheckScheme

func CreateListQualityCheckSchemeRequest ¶

func CreateListQualityCheckSchemeRequest() (request *ListQualityCheckSchemeRequest)

CreateListQualityCheckSchemeRequest creates a request to invoke ListQualityCheckScheme API

type ListQualityCheckSchemeResponse ¶

type ListQualityCheckSchemeResponse struct {
	*responses.BaseResponse
	RequestId     string                         `json:"RequestId" xml:"RequestId"`
	Success       bool                           `json:"Success" xml:"Success"`
	ResultCountId string                         `json:"ResultCountId" xml:"ResultCountId"`
	Code          string                         `json:"Code" xml:"Code"`
	Message       string                         `json:"Message" xml:"Message"`
	PageNumber    int                            `json:"PageNumber" xml:"PageNumber"`
	PageSize      int                            `json:"PageSize" xml:"PageSize"`
	Count         int                            `json:"Count" xml:"Count"`
	Data          []DataInListQualityCheckScheme `json:"Data" xml:"Data"`
}

ListQualityCheckSchemeResponse is the response struct for api ListQualityCheckScheme

func CreateListQualityCheckSchemeResponse ¶

func CreateListQualityCheckSchemeResponse() (response *ListQualityCheckSchemeResponse)

CreateListQualityCheckSchemeResponse creates a response to parse from ListQualityCheckScheme response

type ListRolesRequest ¶

type ListRolesRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListRolesRequest is the request struct for api ListRoles

func CreateListRolesRequest ¶

func CreateListRolesRequest() (request *ListRolesRequest)

CreateListRolesRequest creates a request to invoke ListRoles API

type ListRolesResponse ¶

type ListRolesResponse struct {
	*responses.BaseResponse
	Code      string          `json:"Code" xml:"Code"`
	Message   string          `json:"Message" xml:"Message"`
	RequestId string          `json:"RequestId" xml:"RequestId"`
	Success   bool            `json:"Success" xml:"Success"`
	Data      DataInListRoles `json:"Data" xml:"Data"`
}

ListRolesResponse is the response struct for api ListRoles

func CreateListRolesResponse ¶

func CreateListRolesResponse() (response *ListRolesResponse)

CreateListRolesResponse creates a response to parse from ListRoles response

type ListRulesRequest ¶

type ListRulesRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListRulesRequest is the request struct for api ListRules

func CreateListRulesRequest ¶

func CreateListRulesRequest() (request *ListRulesRequest)

CreateListRulesRequest creates a request to invoke ListRules API

type ListRulesResponse ¶

type ListRulesResponse struct {
	*responses.BaseResponse
	RequestId  string `json:"RequestId" xml:"RequestId"`
	Success    bool   `json:"Success" xml:"Success"`
	Code       string `json:"Code" xml:"Code"`
	Message    string `json:"Message" xml:"Message"`
	PageNumber int    `json:"PageNumber" xml:"PageNumber"`
	PageSize   int    `json:"PageSize" xml:"PageSize"`
	Count      int    `json:"Count" xml:"Count"`
	Data       []Rule `json:"Data" xml:"Data"`
}

ListRulesResponse is the response struct for api ListRules

func CreateListRulesResponse ¶

func CreateListRulesResponse() (response *ListRulesResponse)

CreateListRulesResponse creates a response to parse from ListRules response

type ListSkillGroupConfigRequest ¶

type ListSkillGroupConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListSkillGroupConfigRequest is the request struct for api ListSkillGroupConfig

func CreateListSkillGroupConfigRequest ¶

func CreateListSkillGroupConfigRequest() (request *ListSkillGroupConfigRequest)

CreateListSkillGroupConfigRequest creates a request to invoke ListSkillGroupConfig API

type ListSkillGroupConfigResponse ¶

type ListSkillGroupConfigResponse struct {
	*responses.BaseResponse
	Code      string                     `json:"Code" xml:"Code"`
	Message   string                     `json:"Message" xml:"Message"`
	RequestId string                     `json:"RequestId" xml:"RequestId"`
	Success   bool                       `json:"Success" xml:"Success"`
	Data      DataInListSkillGroupConfig `json:"Data" xml:"Data"`
}

ListSkillGroupConfigResponse is the response struct for api ListSkillGroupConfig

func CreateListSkillGroupConfigResponse ¶

func CreateListSkillGroupConfigResponse() (response *ListSkillGroupConfigResponse)

CreateListSkillGroupConfigResponse creates a response to parse from ListSkillGroupConfig response

type ListTaskAssignRulesRequest ¶

type ListTaskAssignRulesRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListTaskAssignRulesRequest is the request struct for api ListTaskAssignRules

func CreateListTaskAssignRulesRequest ¶

func CreateListTaskAssignRulesRequest() (request *ListTaskAssignRulesRequest)

CreateListTaskAssignRulesRequest creates a request to invoke ListTaskAssignRules API

type ListTaskAssignRulesResponse ¶

type ListTaskAssignRulesResponse struct {
	*responses.BaseResponse
	RequestId  string                    `json:"RequestId" xml:"RequestId"`
	Success    bool                      `json:"Success" xml:"Success"`
	Code       string                    `json:"Code" xml:"Code"`
	Message    string                    `json:"Message" xml:"Message"`
	PageNumber int                       `json:"PageNumber" xml:"PageNumber"`
	PageSize   int                       `json:"PageSize" xml:"PageSize"`
	Count      int                       `json:"Count" xml:"Count"`
	Data       DataInListTaskAssignRules `json:"Data" xml:"Data"`
}

ListTaskAssignRulesResponse is the response struct for api ListTaskAssignRules

func CreateListTaskAssignRulesResponse ¶

func CreateListTaskAssignRulesResponse() (response *ListTaskAssignRulesResponse)

CreateListTaskAssignRulesResponse creates a response to parse from ListTaskAssignRules response

type ListUsersRequest ¶

type ListUsersRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListUsersRequest is the request struct for api ListUsers

func CreateListUsersRequest ¶

func CreateListUsersRequest() (request *ListUsersRequest)

CreateListUsersRequest creates a request to invoke ListUsers API

type ListUsersResponse ¶

type ListUsersResponse struct {
	*responses.BaseResponse
	RequestId  string          `json:"RequestId" xml:"RequestId"`
	Success    bool            `json:"Success" xml:"Success"`
	Code       string          `json:"Code" xml:"Code"`
	Message    string          `json:"Message" xml:"Message"`
	PageNumber int             `json:"PageNumber" xml:"PageNumber"`
	PageSize   int             `json:"PageSize" xml:"PageSize"`
	Count      int             `json:"Count" xml:"Count"`
	Data       DataInListUsers `json:"Data" xml:"Data"`
}

ListUsersResponse is the response struct for api ListUsers

func CreateListUsersResponse ¶

func CreateListUsersResponse() (response *ListUsersResponse)

CreateListUsersResponse creates a response to parse from ListUsers response

type ListWarningConfigRequest ¶

type ListWarningConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

ListWarningConfigRequest is the request struct for api ListWarningConfig

func CreateListWarningConfigRequest ¶

func CreateListWarningConfigRequest() (request *ListWarningConfigRequest)

CreateListWarningConfigRequest creates a request to invoke ListWarningConfig API

type ListWarningConfigResponse ¶

type ListWarningConfigResponse struct {
	*responses.BaseResponse
	Code      string                  `json:"Code" xml:"Code"`
	Message   string                  `json:"Message" xml:"Message"`
	RequestId string                  `json:"RequestId" xml:"RequestId"`
	Success   bool                    `json:"Success" xml:"Success"`
	Data      DataInListWarningConfig `json:"Data" xml:"Data"`
}

ListWarningConfigResponse is the response struct for api ListWarningConfig

func CreateListWarningConfigResponse ¶

func CreateListWarningConfigResponse() (response *ListWarningConfigResponse)

CreateListWarningConfigResponse creates a response to parse from ListWarningConfig response

type ManualScoreInfo ¶

type ManualScoreInfo struct {
	ScoreSubName      string                               `json:"ScoreSubName" xml:"ScoreSubName"`
	Complainable      bool                                 `json:"Complainable" xml:"Complainable"`
	ScoreNum          int                                  `json:"ScoreNum" xml:"ScoreNum"`
	ScoreSubId        int64                                `json:"ScoreSubId" xml:"ScoreSubId"`
	ScoreId           int64                                `json:"ScoreId" xml:"ScoreId"`
	ComplainHistories ComplainHistoriesInGetResultToReview `json:"ComplainHistories" xml:"ComplainHistories"`
}

ManualScoreInfo is a nested struct in qualitycheck response

type ManualScoreInfoList ¶

type ManualScoreInfoList struct {
	ManualScoreInfo []ManualScoreInfo `json:"ManualScoreInfo" xml:"ManualScoreInfo"`
}

ManualScoreInfoList is a nested struct in qualitycheck response

type ModelCustomizationDataSetPo ¶

type ModelCustomizationDataSetPo struct {
	TaskType            int    `json:"TaskType" xml:"TaskType"`
	CreateTime          string `json:"CreateTime" xml:"CreateTime"`
	ModelStatus         int    `json:"ModelStatus" xml:"ModelStatus"`
	ModelName           string `json:"ModelName" xml:"ModelName"`
	ModelId             int64  `json:"ModelId" xml:"ModelId"`
	ModeCustomizationId string `json:"ModeCustomizationId" xml:"ModeCustomizationId"`
}

ModelCustomizationDataSetPo is a nested struct in qualitycheck response

type OperKeyWords ¶

type OperKeyWords struct {
	OperKeyWord []string `json:"OperKeyWord" xml:"OperKeyWord"`
}

OperKeyWords is a nested struct in qualitycheck response

type OperatorBasicInfo ¶

type OperatorBasicInfo struct {
	Type     string `json:"Type" xml:"Type"`
	Oid      string `json:"Oid" xml:"Oid"`
	OperName string `json:"OperName" xml:"OperName"`
	Param    Param  `json:"Param" xml:"Param"`
}

OperatorBasicInfo is a nested struct in qualitycheck response

type Operators ¶

type Operators struct {
	OperatorBasicInfo []OperatorBasicInfo `json:"OperatorBasicInfo" xml:"OperatorBasicInfo"`
}

Operators is a nested struct in qualitycheck response

type Param ¶

type Param struct {
	DifferentRole         bool               `json:"DifferentRole" xml:"DifferentRole"`
	Regex                 string             `json:"Regex" xml:"Regex"`
	TargetRole            string             `json:"TargetRole" xml:"TargetRole"`
	VelocityInMint        int                `json:"VelocityInMint" xml:"VelocityInMint"`
	Average               bool               `json:"Average" xml:"Average"`
	KeywordExtension      bool               `json:"KeywordExtension" xml:"KeywordExtension"`
	Score                 int                `json:"Score" xml:"Score"`
	NotRegex              string             `json:"NotRegex" xml:"NotRegex"`
	CompareOperator       string             `json:"CompareOperator" xml:"CompareOperator"`
	DelayTime             int                `json:"DelayTime" xml:"DelayTime"`
	KeywordMatchSize      int                `json:"KeywordMatchSize" xml:"KeywordMatchSize"`
	HitTime               int                `json:"HitTime" xml:"HitTime"`
	BeginType             string             `json:"BeginType" xml:"BeginType"`
	Target                int                `json:"Target" xml:"Target"`
	MaxEmotionChangeValue int                `json:"MaxEmotionChangeValue" xml:"MaxEmotionChangeValue"`
	Threshold             float64            `json:"Threshold" xml:"Threshold"`
	From                  int                `json:"From" xml:"From"`
	FromEnd               bool               `json:"FromEnd" xml:"FromEnd"`
	MinWordSize           int                `json:"MinWordSize" xml:"MinWordSize"`
	InSentence            bool               `json:"InSentence" xml:"InSentence"`
	Phrase                string             `json:"Phrase" xml:"Phrase"`
	SimilarityThreshold   float64            `json:"Similarity_threshold" xml:"Similarity_threshold"`
	CheckType             int                `json:"CheckType" xml:"CheckType"`
	Interval              int                `json:"Interval" xml:"Interval"`
	ContextChatMatch      bool               `json:"ContextChatMatch" xml:"ContextChatMatch"`
	Excludes              Excludes           `json:"Excludes" xml:"Excludes"`
	AntModelInfo          AntModelInfo       `json:"AntModelInfo" xml:"AntModelInfo"`
	Pvalues               Pvalues            `json:"Pvalues" xml:"Pvalues"`
	References            References         `json:"References" xml:"References"`
	SimilarlySentences    SimilarlySentences `json:"SimilarlySentences" xml:"SimilarlySentences"`
	OperKeyWords          OperKeyWords       `json:"OperKeyWords" xml:"OperKeyWords"`
}

Param is a nested struct in qualitycheck response

type Phrase ¶

type Phrase struct {
	Words           string `json:"Words" xml:"Words"`
	Role            string `json:"Role" xml:"Role"`
	SpeechRate      int    `json:"SpeechRate" xml:"SpeechRate"`
	End             int    `json:"End" xml:"End"`
	SilenceDuration int    `json:"SilenceDuration" xml:"SilenceDuration"`
	EmotionValue    int    `json:"EmotionValue" xml:"EmotionValue"`
	Begin           int64  `json:"Begin" xml:"Begin"`
}

Phrase is a nested struct in qualitycheck response

type PhraseInGetResultToReview ¶

type PhraseInGetResultToReview struct {
	Words        string `json:"Words" xml:"Words"`
	Begin        int64  `json:"Begin" xml:"Begin"`
	Identity     string `json:"Identity" xml:"Identity"`
	Pid          int    `json:"Pid" xml:"Pid"`
	EmotionValue int    `json:"EmotionValue" xml:"EmotionValue"`
	End          int64  `json:"End" xml:"End"`
	Role         string `json:"Role" xml:"Role"`
}

PhraseInGetResultToReview is a nested struct in qualitycheck response

type PhraseInSyncQualityCheck ¶

type PhraseInSyncQualityCheck struct {
	Words           string `json:"Words" xml:"Words"`
	Identity        string `json:"Identity" xml:"Identity"`
	Begin           int64  `json:"Begin" xml:"Begin"`
	EmotionValue    int    `json:"EmotionValue" xml:"EmotionValue"`
	End             int64  `json:"End" xml:"End"`
	SpeechRate      int    `json:"SpeechRate" xml:"SpeechRate"`
	Role            string `json:"Role" xml:"Role"`
	SilenceDuration int    `json:"SilenceDuration" xml:"SilenceDuration"`
}

PhraseInSyncQualityCheck is a nested struct in qualitycheck response

type PhraseInUploadDataSync ¶

type PhraseInUploadDataSync struct {
	Words     string `json:"Words" xml:"Words"`
	Identity  string `json:"Identity" xml:"Identity"`
	Begin     int64  `json:"Begin" xml:"Begin"`
	BeginTime string `json:"BeginTime" xml:"BeginTime"`
	End       int64  `json:"End" xml:"End"`
	Role      string `json:"Role" xml:"Role"`
}

PhraseInUploadDataSync is a nested struct in qualitycheck response

type Precision ¶

type Precision struct {
	Status     int     `json:"Status" xml:"Status"`
	TaskId     string  `json:"TaskId" xml:"TaskId"`
	ModelName  string  `json:"ModelName" xml:"ModelName"`
	CreateTime string  `json:"CreateTime" xml:"CreateTime"`
	Precision  float64 `json:"Precision" xml:"Precision"`
	ModelId    int64   `json:"ModelId" xml:"ModelId"`
}

Precision is a nested struct in qualitycheck response

type PrecisionTask ¶

type PrecisionTask struct {
	Status         int                           `json:"Status" xml:"Status"`
	UpdateTime     string                        `json:"UpdateTime" xml:"UpdateTime"`
	IncorrectWords int                           `json:"IncorrectWords" xml:"IncorrectWords"`
	CreateTime     string                        `json:"CreateTime" xml:"CreateTime"`
	DataSetId      int64                         `json:"DataSetId" xml:"DataSetId"`
	VerifiedCount  int                           `json:"VerifiedCount" xml:"VerifiedCount"`
	Source         int                           `json:"Source" xml:"Source"`
	TotalCount     int                           `json:"TotalCount" xml:"TotalCount"`
	DataSetName    string                        `json:"DataSetName" xml:"DataSetName"`
	Duration       int                           `json:"Duration" xml:"Duration"`
	Name           string                        `json:"Name" xml:"Name"`
	TaskId         string                        `json:"TaskId" xml:"TaskId"`
	Precisions     PrecisionsInListPrecisionTask `json:"Precisions" xml:"Precisions"`
}

PrecisionTask is a nested struct in qualitycheck response

type PrecisionsInGetPrecisionTask ¶

type PrecisionsInGetPrecisionTask struct {
	Precision []Precision `json:"Precision" xml:"Precision"`
}

PrecisionsInGetPrecisionTask is a nested struct in qualitycheck response

type PrecisionsInListPrecisionTask ¶

type PrecisionsInListPrecisionTask struct {
	Precision []Precision `json:"Precision" xml:"Precision"`
}

PrecisionsInListPrecisionTask is a nested struct in qualitycheck response

type Pvalues ¶

type Pvalues struct {
	Pvalues []string `json:"Pvalues" xml:"Pvalues"`
}

Pvalues is a nested struct in qualitycheck response

type Range ¶

type Range struct {
	To   int `json:"To" xml:"To"`
	From int `json:"From" xml:"From"`
}

Range is a nested struct in qualitycheck response

type Recording ¶

type Recording struct {
	Name          string `json:"Name" xml:"Name"`
	Remark5       int64  `json:"Remark5" xml:"Remark5"`
	CallTime      string `json:"CallTime" xml:"CallTime"`
	DurationAudio int64  `json:"DurationAudio" xml:"DurationAudio"`
	CallId        string `json:"CallId" xml:"CallId"`
	Caller        string `json:"Caller" xml:"Caller"`
	Remark7       string `json:"Remark7" xml:"Remark7"`
	Remark9       string `json:"Remark9" xml:"Remark9"`
	Remark11      string `json:"Remark11" xml:"Remark11"`
	Remark2       string `json:"Remark2" xml:"Remark2"`
	Id            string `json:"Id" xml:"Id"`
	Remark4       string `json:"Remark4" xml:"Remark4"`
	Duration      int64  `json:"Duration" xml:"Duration"`
	Business      string `json:"Business" xml:"Business"`
	DialogueSize  int    `json:"DialogueSize" xml:"DialogueSize"`
	Remark6       string `json:"Remark6" xml:"Remark6"`
	Remark13      string `json:"Remark13" xml:"Remark13"`
	Callee        string `json:"Callee" xml:"Callee"`
	Remark1       string `json:"Remark1" xml:"Remark1"`
	PrimaryId     string `json:"PrimaryId" xml:"PrimaryId"`
	CallType      int    `json:"CallType" xml:"CallType"`
	Url           string `json:"Url" xml:"Url"`
	Remark12      string `json:"Remark12" xml:"Remark12"`
	Remark8       string `json:"Remark8" xml:"Remark8"`
	DataSetName   string `json:"DataSetName" xml:"DataSetName"`
	Remark10      string `json:"Remark10" xml:"Remark10"`
	Remark3       string `json:"Remark3" xml:"Remark3"`
}

Recording is a nested struct in qualitycheck response

type References ¶

type References struct {
	Reference []string `json:"Reference" xml:"Reference"`
}

References is a nested struct in qualitycheck response

type RestartAsrTaskRequest ¶

type RestartAsrTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

RestartAsrTaskRequest is the request struct for api RestartAsrTask

func CreateRestartAsrTaskRequest ¶

func CreateRestartAsrTaskRequest() (request *RestartAsrTaskRequest)

CreateRestartAsrTaskRequest creates a request to invoke RestartAsrTask API

type RestartAsrTaskResponse ¶

type RestartAsrTaskResponse struct {
	*responses.BaseResponse
	Code      string               `json:"Code" xml:"Code"`
	Message   string               `json:"Message" xml:"Message"`
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Success   bool                 `json:"Success" xml:"Success"`
	Data      DataInRestartAsrTask `json:"Data" xml:"Data"`
}

RestartAsrTaskResponse is the response struct for api RestartAsrTask

func CreateRestartAsrTaskResponse ¶

func CreateRestartAsrTaskResponse() (response *RestartAsrTaskResponse)

CreateRestartAsrTaskResponse creates a response to parse from RestartAsrTask response

type RestartResult ¶

type RestartResult struct {
	Message string `json:"Message" xml:"Message"`
	Data    string `json:"Data" xml:"Data"`
	Success bool   `json:"Success" xml:"Success"`
}

RestartResult is a nested struct in qualitycheck response

type ResultInfo ¶

type ResultInfo struct {
	Comments        string                `json:"Comments" xml:"Comments"`
	CreateTimeLong  string                `json:"CreateTimeLong" xml:"CreateTimeLong"`
	RuleName        string                `json:"RuleName" xml:"RuleName"`
	ErrorMessage    string                `json:"ErrorMessage" xml:"ErrorMessage"`
	ReviewStatus    int                   `json:"ReviewStatus" xml:"ReviewStatus"`
	CreateTime      string                `json:"CreateTime" xml:"CreateTime"`
	ReviewResult    int                   `json:"ReviewResult" xml:"ReviewResult"`
	ReviewTime      string                `json:"ReviewTime" xml:"ReviewTime"`
	Resolver        string                `json:"Resolver" xml:"Resolver"`
	TaskId          string                `json:"TaskId" xml:"TaskId"`
	Rid             int64                 `json:"Rid" xml:"Rid"`
	LastDataId      string                `json:"LastDataId" xml:"LastDataId"`
	Status          int                   `json:"Status" xml:"Status"`
	ReviewTimeLong  string                `json:"ReviewTimeLong" xml:"ReviewTimeLong"`
	Reviewer        string                `json:"Reviewer" xml:"Reviewer"`
	TaskName        string                `json:"TaskName" xml:"TaskName"`
	Score           int                   `json:"Score" xml:"Score"`
	AssignmentTime  string                `json:"AssignmentTime" xml:"AssignmentTime"`
	ReviewType      int                   `json:"ReviewType" xml:"ReviewType"`
	SchemeIdList    SchemeIdList          `json:"SchemeIdList" xml:"SchemeIdList"`
	SchemeNameList  SchemeNameList        `json:"SchemeNameList" xml:"SchemeNameList"`
	HandScoreIdList HandScoreIdList       `json:"HandScoreIdList" xml:"HandScoreIdList"`
	Agent           Agent                 `json:"Agent" xml:"Agent"`
	Recording       Recording             `json:"Recording" xml:"Recording"`
	Rules           RulesInUploadDataSync `json:"Rules" xml:"Rules"`
	AsrResult       []AsrResultItem       `json:"AsrResult" xml:"AsrResult"`
	HitScore        HitScore              `json:"HitScore" xml:"HitScore"`
	HitResult       []HitResultItem       `json:"HitResult" xml:"HitResult"`
}

ResultInfo is a nested struct in qualitycheck response

type ResultInfoInGetSyncResult ¶

type ResultInfoInGetSyncResult struct {
	Status       int             `json:"Status" xml:"Status"`
	ErrorMessage string          `json:"ErrorMessage" xml:"ErrorMessage"`
	Reviewer     string          `json:"Reviewer" xml:"Reviewer"`
	CreateTime   string          `json:"CreateTime" xml:"CreateTime"`
	ReviewStatus int             `json:"ReviewStatus" xml:"ReviewStatus"`
	TaskName     string          `json:"TaskName" xml:"TaskName"`
	Comments     string          `json:"Comments" xml:"Comments"`
	ReviewResult int             `json:"ReviewResult" xml:"ReviewResult"`
	Score        int             `json:"Score" xml:"Score"`
	TaskId       string          `json:"TaskId" xml:"TaskId"`
	Resolver     string          `json:"Resolver" xml:"Resolver"`
	Recording    Recording       `json:"Recording" xml:"Recording"`
	Agent        Agent           `json:"Agent" xml:"Agent"`
	AsrResult    []AsrResultItem `json:"AsrResult" xml:"AsrResult"`
	HitResult    []HitResultItem `json:"HitResult" xml:"HitResult"`
}

ResultInfoInGetSyncResult is a nested struct in qualitycheck response

type ReviewHistory ¶

type ReviewHistory struct {
	Type           int    `json:"Type" xml:"Type"`
	OperatorName   string `json:"OperatorName" xml:"OperatorName"`
	TimeStr        string `json:"TimeStr" xml:"TimeStr"`
	Score          int    `json:"Score" xml:"Score"`
	ReviewResult   int    `json:"ReviewResult" xml:"ReviewResult"`
	ComplainResult int    `json:"ComplainResult" xml:"ComplainResult"`
	OldScore       int    `json:"OldScore" xml:"OldScore"`
}

ReviewHistory is a nested struct in qualitycheck response

type ReviewHistoryList ¶

type ReviewHistoryList struct {
	ReviewHistory []ReviewHistory `json:"ReviewHistory" xml:"ReviewHistory"`
}

ReviewHistoryList is a nested struct in qualitycheck response

type ReviewInfo ¶

type ReviewInfo struct {
	ReviewResult int    `json:"ReviewResult" xml:"ReviewResult"`
	ReviewTime   string `json:"ReviewTime" xml:"ReviewTime"`
	HitId        string `json:"HitId" xml:"HitId"`
	Reviewer     string `json:"Reviewer" xml:"Reviewer"`
	Rid          int64  `json:"Rid" xml:"Rid"`
}

ReviewInfo is a nested struct in qualitycheck response

type Reviewer ¶

type Reviewer struct {
	ReviewerId   string `json:"ReviewerId" xml:"ReviewerId"`
	ReviewerName string `json:"ReviewerName" xml:"ReviewerName"`
}

Reviewer is a nested struct in qualitycheck response

type Reviewers ¶

type Reviewers struct {
	Reviewer []Reviewer `json:"Reviewer" xml:"Reviewer"`
}

Reviewers is a nested struct in qualitycheck response

type RidList ¶

type RidList struct {
	RidList []string `json:"RidList" xml:"RidList"`
}

RidList is a nested struct in qualitycheck response

type Role ¶

type Role struct {
	DisplayName string `json:"DisplayName" xml:"DisplayName"`
	UpdateTime  string `json:"UpdateTime" xml:"UpdateTime"`
	CreateTime  string `json:"CreateTime" xml:"CreateTime"`
	Name        string `json:"Name" xml:"Name"`
	Id          int64  `json:"Id" xml:"Id"`
	Level       int    `json:"Level" xml:"Level"`
}

Role is a nested struct in qualitycheck response

type Rule ¶

type Rule struct {
	Type                     int      `json:"Type" xml:"Type"`
	RuleType                 int      `json:"RuleType" xml:"RuleType"`
	CreateTime               string   `json:"CreateTime" xml:"CreateTime"`
	Comments                 string   `json:"Comments" xml:"Comments"`
	TypeName                 string   `json:"TypeName" xml:"TypeName"`
	Name                     string   `json:"Name" xml:"Name"`
	Rid                      int64    `json:"Rid" xml:"Rid"`
	BusinessCategoryNameList []string `json:"BusinessCategoryNameList" xml:"BusinessCategoryNameList"`
}

Rule is a nested struct in qualitycheck response

type RuleBasicInfo ¶

type RuleBasicInfo struct {
	Name               string             `json:"Name" xml:"Name"`
	Rid                string             `json:"Rid" xml:"Rid"`
	RuleLambda         string             `json:"RuleLambda" xml:"RuleLambda"`
	Triggers           Triggers           `json:"Triggers" xml:"Triggers"`
	BusinessCategories BusinessCategories `json:"BusinessCategories" xml:"BusinessCategories"`
}

RuleBasicInfo is a nested struct in qualitycheck response

type RuleCountInfo ¶

type RuleCountInfo struct {
	Type     int    `json:"Type" xml:"Type"`
	TypeName string `json:"TypeName" xml:"TypeName"`
	Select   bool   `json:"Select" xml:"Select"`
}

RuleCountInfo is a nested struct in qualitycheck response

type RuleHitInfo ¶

type RuleHitInfo struct {
	Rid           string              `json:"Rid" xml:"Rid"`
	RuleName      string              `json:"RuleName" xml:"RuleName"`
	Tid           string              `json:"Tid" xml:"Tid"`
	Hit           HitInUploadDataSync `json:"Hit" xml:"Hit"`
	ConditionInfo ConditionInfo       `json:"ConditionInfo" xml:"ConditionInfo"`
}

RuleHitInfo is a nested struct in qualitycheck response

type RuleHitInfoInUploadDataSync ¶

type RuleHitInfoInUploadDataSync struct {
	Tid           string              `json:"Tid" xml:"Tid"`
	Rid           string              `json:"Rid" xml:"Rid"`
	Hit           HitInUploadDataSync `json:"Hit" xml:"Hit"`
	ConditionInfo ConditionInfo       `json:"ConditionInfo" xml:"ConditionInfo"`
}

RuleHitInfoInUploadDataSync is a nested struct in qualitycheck response

type RuleInfo ¶

type RuleInfo struct {
	Status                   int                               `json:"Status" xml:"Status"`
	Type                     int                               `json:"Type" xml:"Type"`
	ScoreSubId               int                               `json:"ScoreSubId" xml:"ScoreSubId"`
	IsOnline                 int                               `json:"IsOnline" xml:"IsOnline"`
	CreateTime               string                            `json:"CreateTime" xml:"CreateTime"`
	CreateEmpid              string                            `json:"CreateEmpid" xml:"CreateEmpid"`
	LastUpdateEmpid          string                            `json:"LastUpdateEmpid" xml:"LastUpdateEmpid"`
	IsDelete                 int                               `json:"IsDelete" xml:"IsDelete"`
	Rid                      string                            `json:"Rid" xml:"Rid"`
	RuleScoreType            int                               `json:"RuleScoreType" xml:"RuleScoreType"`
	EndTime                  string                            `json:"EndTime" xml:"EndTime"`
	Weight                   string                            `json:"Weight" xml:"Weight"`
	StartTime                string                            `json:"StartTime" xml:"StartTime"`
	RuleLambda               string                            `json:"RuleLambda" xml:"RuleLambda"`
	ScoreSubName             string                            `json:"ScoreSubName" xml:"ScoreSubName"`
	AutoReview               int                               `json:"AutoReview" xml:"AutoReview"`
	Comments                 string                            `json:"Comments" xml:"Comments"`
	LastUpdateTime           string                            `json:"LastUpdateTime" xml:"LastUpdateTime"`
	ScoreName                string                            `json:"ScoreName" xml:"ScoreName"`
	Name                     string                            `json:"Name" xml:"Name"`
	ScoreId                  int                               `json:"ScoreId" xml:"ScoreId"`
	BusinessCategoryNameList BusinessCategoryNameListInGetRule `json:"BusinessCategoryNameList" xml:"BusinessCategoryNameList"`
}

RuleInfo is a nested struct in qualitycheck response

type RuleList ¶

type RuleList struct {
	Rules []Rules `json:"Rules" xml:"Rules"`
}

RuleList is a nested struct in qualitycheck response

type RuleListInGetSkillGroupConfig ¶

type RuleListInGetSkillGroupConfig struct {
	RuleNameInfo []RuleNameInfo `json:"RuleNameInfo" xml:"RuleNameInfo"`
}

RuleListInGetSkillGroupConfig is a nested struct in qualitycheck response

type RuleListInListQualityCheckScheme ¶

type RuleListInListQualityCheckScheme struct {
	RuleList []RuleList `json:"ruleList" xml:"ruleList"`
}

RuleListInListQualityCheckScheme is a nested struct in qualitycheck response

type RuleListInListSkillGroupConfig ¶

type RuleListInListSkillGroupConfig struct {
	RuleNameInfo []RuleNameInfo `json:"RuleNameInfo" xml:"RuleNameInfo"`
}

RuleListInListSkillGroupConfig is a nested struct in qualitycheck response

type RuleListInListWarningConfig ¶

type RuleListInListWarningConfig struct {
	WarningRule []WarningRule `json:"WarningRule" xml:"WarningRule"`
}

RuleListInListWarningConfig is a nested struct in qualitycheck response

type RuleNameInfo ¶

type RuleNameInfo struct {
	RuleName string `json:"RuleName" xml:"RuleName"`
	Rid      int64  `json:"Rid" xml:"Rid"`
}

RuleNameInfo is a nested struct in qualitycheck response

type Rules ¶

type Rules struct {
	Name          string `json:"Name" xml:"Name"`
	Rid           int64  `json:"Rid" xml:"Rid"`
	ScoreNum      int    `json:"ScoreNum" xml:"ScoreNum"`
	TargetType    int    `json:"TargetType" xml:"TargetType"`
	ScoreNumType  int    `json:"ScoreNumType" xml:"ScoreNumType"`
	ScoreType     int    `json:"ScoreType" xml:"ScoreType"`
	CheckType     int    `json:"CheckType" xml:"CheckType"`
	RuleScoreType int    `json:"RuleScoreType" xml:"RuleScoreType"`
}

Rules is a nested struct in qualitycheck response

type RulesInGetRule ¶

type RulesInGetRule struct {
	RuleInfo []RuleInfo `json:"RuleInfo" xml:"RuleInfo"`
}

RulesInGetRule is a nested struct in qualitycheck response

type RulesInGetRuleDetail ¶

type RulesInGetRuleDetail struct {
	RuleBasicInfo []RuleBasicInfo `json:"RuleBasicInfo" xml:"RuleBasicInfo"`
}

RulesInGetRuleDetail is a nested struct in qualitycheck response

type RulesInListQualityCheckScheme ¶

type RulesInListQualityCheckScheme struct {
	Rules []Rules `json:"rules" xml:"rules"`
}

RulesInListQualityCheckScheme is a nested struct in qualitycheck response

type RulesInListTaskAssignRules ¶

type RulesInListTaskAssignRules struct {
	RuleBasicInfo []RuleBasicInfo `json:"RuleBasicInfo" xml:"RuleBasicInfo"`
}

RulesInListTaskAssignRules is a nested struct in qualitycheck response

type RulesInSyncQualityCheck ¶

type RulesInSyncQualityCheck struct {
	RuleHitInfo []RuleHitInfo `json:"RuleHitInfo" xml:"RuleHitInfo"`
}

RulesInSyncQualityCheck is a nested struct in qualitycheck response

type RulesInUploadDataSync ¶

type RulesInUploadDataSync struct {
	RuleHitInfo []RuleHitInfoInUploadDataSync `json:"RuleHitInfo" xml:"RuleHitInfo"`
}

RulesInUploadDataSync is a nested struct in qualitycheck response

type SamplingMode ¶

type SamplingMode struct {
	NumberOfDraws          int                `json:"NumberOfDraws" xml:"NumberOfDraws"`
	AnyNumberOfDraws       int                `json:"AnyNumberOfDraws" xml:"AnyNumberOfDraws"`
	Limit                  int                `json:"Limit" xml:"Limit"`
	Proportion             float64            `json:"Proportion" xml:"Proportion"`
	Dimension              int                `json:"Dimension" xml:"Dimension"`
	Designated             bool               `json:"Designated" xml:"Designated"`
	RandomInspectionNumber int                `json:"RandomInspectionNumber" xml:"RandomInspectionNumber"`
	SamplingModeAgents     SamplingModeAgents `json:"SamplingModeAgents" xml:"SamplingModeAgents"`
}

SamplingMode is a nested struct in qualitycheck response

type SamplingModeAgent ¶

type SamplingModeAgent struct {
	AgentName string `json:"AgentName" xml:"AgentName"`
	AgentId   string `json:"AgentId" xml:"AgentId"`
}

SamplingModeAgent is a nested struct in qualitycheck response

type SamplingModeAgents ¶

type SamplingModeAgents struct {
	SamplingModeAgent []SamplingModeAgent `json:"SamplingModeAgent" xml:"SamplingModeAgent"`
}

SamplingModeAgents is a nested struct in qualitycheck response

type SaveConfigDataSetRequest ¶

type SaveConfigDataSetRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SaveConfigDataSetRequest is the request struct for api SaveConfigDataSet

func CreateSaveConfigDataSetRequest ¶

func CreateSaveConfigDataSetRequest() (request *SaveConfigDataSetRequest)

CreateSaveConfigDataSetRequest creates a request to invoke SaveConfigDataSet API

type SaveConfigDataSetResponse ¶

type SaveConfigDataSetResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

SaveConfigDataSetResponse is the response struct for api SaveConfigDataSet

func CreateSaveConfigDataSetResponse ¶

func CreateSaveConfigDataSetResponse() (response *SaveConfigDataSetResponse)

CreateSaveConfigDataSetResponse creates a response to parse from SaveConfigDataSet response

type SchemeCheckTypeList ¶

type SchemeCheckTypeList struct {
	Enable     int    `json:"Enable" xml:"Enable"`
	Score      int    `json:"Score" xml:"Score"`
	TargetType int    `json:"TargetType" xml:"TargetType"`
	CheckType  int    `json:"CheckType" xml:"CheckType"`
	CheckName  string `json:"CheckName" xml:"CheckName"`
}

SchemeCheckTypeList is a nested struct in qualitycheck response

type SchemeCheckTypeListInListQualityCheckScheme ¶

type SchemeCheckTypeListInListQualityCheckScheme struct {
	SchemeCheckTypeList []SchemeCheckTypeList `json:"schemeCheckTypeList" xml:"schemeCheckTypeList"`
}

SchemeCheckTypeListInListQualityCheckScheme is a nested struct in qualitycheck response

type SchemeIdList ¶

type SchemeIdList struct {
	SchemeIdList []int64 `json:"SchemeIdList" xml:"SchemeIdList"`
}

SchemeIdList is a nested struct in qualitycheck response

type SchemeNameList ¶

type SchemeNameList struct {
	SchemeNameList []string `json:"SchemeNameList" xml:"SchemeNameList"`
}

SchemeNameList is a nested struct in qualitycheck response

type ScoreInfosInGetResultToReview ¶

type ScoreInfosInGetResultToReview struct {
	ScoreParam []ScoreParam `json:"ScoreParam" xml:"ScoreParam"`
}

ScoreInfosInGetResultToReview is a nested struct in qualitycheck response

type ScoreInfosInGetScoreInfo ¶

type ScoreInfosInGetScoreInfo struct {
	ScoreParam []ScoreParamInGetScoreInfo `json:"ScoreParam" xml:"ScoreParam"`
}

ScoreInfosInGetScoreInfo is a nested struct in qualitycheck response

type ScoreParam ¶

type ScoreParam struct {
	Hit          int    `json:"Hit" xml:"Hit"`
	ScoreSubName string `json:"ScoreSubName" xml:"ScoreSubName"`
	ScoreSubId   int64  `json:"ScoreSubId" xml:"ScoreSubId"`
	ScoreNum     int    `json:"ScoreNum" xml:"ScoreNum"`
	ScoreType    int    `json:"ScoreType" xml:"ScoreType"`
}

ScoreParam is a nested struct in qualitycheck response

type ScoreParamInGetScoreInfo ¶

type ScoreParamInGetScoreInfo struct {
	ScoreSubName string `json:"ScoreSubName" xml:"ScoreSubName"`
	ScoreNum     int    `json:"ScoreNum" xml:"ScoreNum"`
	ScoreSubId   int    `json:"ScoreSubId" xml:"ScoreSubId"`
	ScoreType    int    `json:"ScoreType" xml:"ScoreType"`
}

ScoreParamInGetScoreInfo is a nested struct in qualitycheck response

type ScorePo ¶

type ScorePo struct {
	ScoreId    int64                         `json:"ScoreId" xml:"ScoreId"`
	ScoreName  string                        `json:"ScoreName" xml:"ScoreName"`
	ScoreInfos ScoreInfosInGetResultToReview `json:"ScoreInfos" xml:"ScoreInfos"`
}

ScorePo is a nested struct in qualitycheck response

type ScorePoInGetScoreInfo ¶

type ScorePoInGetScoreInfo struct {
	ScoreId    int                      `json:"ScoreId" xml:"ScoreId"`
	ScoreName  string                   `json:"ScoreName" xml:"ScoreName"`
	ScoreInfos ScoreInfosInGetScoreInfo `json:"ScoreInfos" xml:"ScoreInfos"`
}

ScorePoInGetScoreInfo is a nested struct in qualitycheck response

type SimilarlySentences ¶

type SimilarlySentences struct {
	SimilarlySentence []string `json:"SimilarlySentence" xml:"SimilarlySentence"`
}

SimilarlySentences is a nested struct in qualitycheck response

type SkillGroup ¶

type SkillGroup struct {
	SkillName string `json:"SkillName" xml:"SkillName"`
	SkillId   string `json:"SkillId" xml:"SkillId"`
}

SkillGroup is a nested struct in qualitycheck response

type SkillGroupConfig ¶

type SkillGroupConfig struct {
	Type                   int                               `json:"Type" xml:"Type"`
	Status                 int                               `json:"Status" xml:"Status"`
	UpdateTime             string                            `json:"UpdateTime" xml:"UpdateTime"`
	AllContentQualityCheck int                               `json:"AllContentQualityCheck" xml:"AllContentQualityCheck"`
	CreateTime             string                            `json:"CreateTime" xml:"CreateTime"`
	SkillGroupId           string                            `json:"SkillGroupId" xml:"SkillGroupId"`
	ScreenSwitch           bool                              `json:"ScreenSwitch" xml:"ScreenSwitch"`
	InstanceId             string                            `json:"InstanceId" xml:"InstanceId"`
	VocabId                int64                             `json:"VocabId" xml:"VocabId"`
	SkillGroupFrom         int                               `json:"SkillGroupFrom" xml:"SkillGroupFrom"`
	Rid                    string                            `json:"Rid" xml:"Rid"`
	SkillGroupName         string                            `json:"SkillGroupName" xml:"SkillGroupName"`
	ModelName              string                            `json:"ModelName" xml:"ModelName"`
	AllRids                string                            `json:"AllRids" xml:"AllRids"`
	Name                   string                            `json:"Name" xml:"Name"`
	ModelId                int64                             `json:"ModelId" xml:"ModelId"`
	Id                     int64                             `json:"Id" xml:"Id"`
	QualityCheckType       int                               `json:"QualityCheckType" xml:"QualityCheckType"`
	VocabName              string                            `json:"VocabName" xml:"VocabName"`
	RuleList               RuleListInListSkillGroupConfig    `json:"RuleList" xml:"RuleList"`
	AllRuleList            AllRuleListInListSkillGroupConfig `json:"AllRuleList" xml:"AllRuleList"`
	SkillGroupScreens      SkillGroupScreens                 `json:"SkillGroupScreens" xml:"SkillGroupScreens"`
}

SkillGroupConfig is a nested struct in qualitycheck response

type SkillGroupScreen ¶

type SkillGroupScreen struct {
	Value    string `json:"Value" xml:"Value"`
	DataType int    `json:"DataType" xml:"DataType"`
	Symbol   int    `json:"Symbol" xml:"Symbol"`
	Name     string `json:"Name" xml:"Name"`
}

SkillGroupScreen is a nested struct in qualitycheck response

type SkillGroupScreens ¶

type SkillGroupScreens struct {
	SkillGroupScreen []SkillGroupScreen `json:"SkillGroupScreen" xml:"SkillGroupScreen"`
}

SkillGroupScreens is a nested struct in qualitycheck response

type SkillGroups ¶

type SkillGroups struct {
	SkillGroup []SkillGroup `json:"SkillGroup" xml:"SkillGroup"`
}

SkillGroups is a nested struct in qualitycheck response

type Source ¶

type Source struct {
	Position int                         `json:"Position" xml:"Position"`
	Line     LineInGetNextResultToVerify `json:"Line" xml:"Line"`
}

Source is a nested struct in qualitycheck response

type SubmitComplaintRequest ¶

type SubmitComplaintRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SubmitComplaintRequest is the request struct for api SubmitComplaint

func CreateSubmitComplaintRequest ¶

func CreateSubmitComplaintRequest() (request *SubmitComplaintRequest)

CreateSubmitComplaintRequest creates a request to invoke SubmitComplaint API

type SubmitComplaintResponse ¶

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

SubmitComplaintResponse is the response struct for api SubmitComplaint

func CreateSubmitComplaintResponse ¶

func CreateSubmitComplaintResponse() (response *SubmitComplaintResponse)

CreateSubmitComplaintResponse creates a response to parse from SubmitComplaint response

type SubmitPrecisionTaskRequest ¶

type SubmitPrecisionTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SubmitPrecisionTaskRequest is the request struct for api SubmitPrecisionTask

func CreateSubmitPrecisionTaskRequest ¶

func CreateSubmitPrecisionTaskRequest() (request *SubmitPrecisionTaskRequest)

CreateSubmitPrecisionTaskRequest creates a request to invoke SubmitPrecisionTask API

type SubmitPrecisionTaskResponse ¶

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

SubmitPrecisionTaskResponse is the response struct for api SubmitPrecisionTask

func CreateSubmitPrecisionTaskResponse ¶

func CreateSubmitPrecisionTaskResponse() (response *SubmitPrecisionTaskResponse)

CreateSubmitPrecisionTaskResponse creates a response to parse from SubmitPrecisionTask response

type SubmitQualityCheckTaskRequest ¶

type SubmitQualityCheckTaskRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SubmitQualityCheckTaskRequest is the request struct for api SubmitQualityCheckTask

func CreateSubmitQualityCheckTaskRequest ¶

func CreateSubmitQualityCheckTaskRequest() (request *SubmitQualityCheckTaskRequest)

CreateSubmitQualityCheckTaskRequest creates a request to invoke SubmitQualityCheckTask API

type SubmitQualityCheckTaskResponse ¶

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

SubmitQualityCheckTaskResponse is the response struct for api SubmitQualityCheckTask

func CreateSubmitQualityCheckTaskResponse ¶

func CreateSubmitQualityCheckTaskResponse() (response *SubmitQualityCheckTaskResponse)

CreateSubmitQualityCheckTaskResponse creates a response to parse from SubmitQualityCheckTask response

type SubmitReviewInfoRequest ¶

type SubmitReviewInfoRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SubmitReviewInfoRequest is the request struct for api SubmitReviewInfo

func CreateSubmitReviewInfoRequest ¶

func CreateSubmitReviewInfoRequest() (request *SubmitReviewInfoRequest)

CreateSubmitReviewInfoRequest creates a request to invoke SubmitReviewInfo API

type SubmitReviewInfoResponse ¶

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

SubmitReviewInfoResponse is the response struct for api SubmitReviewInfo

func CreateSubmitReviewInfoResponse ¶

func CreateSubmitReviewInfoResponse() (response *SubmitReviewInfoResponse)

CreateSubmitReviewInfoResponse creates a response to parse from SubmitReviewInfo response

type SyncQualityCheckRequest ¶

type SyncQualityCheckRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

SyncQualityCheckRequest is the request struct for api SyncQualityCheck

func CreateSyncQualityCheckRequest ¶

func CreateSyncQualityCheckRequest() (request *SyncQualityCheckRequest)

CreateSyncQualityCheckRequest creates a request to invoke SyncQualityCheck API

type SyncQualityCheckResponse ¶

type SyncQualityCheckResponse struct {
	*responses.BaseResponse
	Code      string                 `json:"Code" xml:"Code"`
	Message   string                 `json:"Message" xml:"Message"`
	RequestId string                 `json:"RequestId" xml:"RequestId"`
	Success   bool                   `json:"Success" xml:"Success"`
	Data      DataInSyncQualityCheck `json:"Data" xml:"Data"`
}

SyncQualityCheckResponse is the response struct for api SyncQualityCheck

func CreateSyncQualityCheckResponse ¶

func CreateSyncQualityCheckResponse() (response *SyncQualityCheckResponse)

CreateSyncQualityCheckResponse creates a response to parse from SyncQualityCheck response

type SynonymList ¶

type SynonymList struct {
	SynonymList []string `json:"SynonymList" xml:"SynonymList"`
}

SynonymList is a nested struct in qualitycheck response

type Target ¶

type Target struct {
	Position int                         `json:"Position" xml:"Position"`
	Line     LineInGetNextResultToVerify `json:"Line" xml:"Line"`
}

Target is a nested struct in qualitycheck response

type TaskAssignRuleInfo ¶

type TaskAssignRuleInfo struct {
	UpdateTime     string                     `json:"UpdateTime" xml:"UpdateTime"`
	SkillGroupsStr string                     `json:"SkillGroupsStr" xml:"SkillGroupsStr"`
	CallTimeEnd    int64                      `json:"CallTimeEnd" xml:"CallTimeEnd"`
	DurationMax    int                        `json:"DurationMax" xml:"DurationMax"`
	CreateTime     string                     `json:"CreateTime" xml:"CreateTime"`
	Priority       int                        `json:"Priority" xml:"Priority"`
	DurationMin    int                        `json:"DurationMin" xml:"DurationMin"`
	AgentsStr      string                     `json:"AgentsStr" xml:"AgentsStr"`
	RuleName       string                     `json:"RuleName" xml:"RuleName"`
	RuleId         int64                      `json:"RuleId" xml:"RuleId"`
	AssignmentType int                        `json:"AssignmentType" xml:"AssignmentType"`
	CallType       int                        `json:"CallType" xml:"CallType"`
	Enabled        int                        `json:"Enabled" xml:"Enabled"`
	CallTimeStart  int64                      `json:"CallTimeStart" xml:"CallTimeStart"`
	SamplingMode   SamplingMode               `json:"SamplingMode" xml:"SamplingMode"`
	Agents         Agents                     `json:"Agents" xml:"Agents"`
	SkillGroups    SkillGroups                `json:"SkillGroups" xml:"SkillGroups"`
	Reviewers      Reviewers                  `json:"Reviewers" xml:"Reviewers"`
	Rules          RulesInListTaskAssignRules `json:"Rules" xml:"Rules"`
}

TaskAssignRuleInfo is a nested struct in qualitycheck response

type ThesaurusPo ¶

type ThesaurusPo struct {
	Business    string      `json:"Business" xml:"Business"`
	Id          int64       `json:"Id" xml:"Id"`
	SynonymList SynonymList `json:"SynonymList" xml:"SynonymList"`
}

ThesaurusPo is a nested struct in qualitycheck response

type Triggers ¶

type Triggers struct {
	Trigger []string `json:"Trigger" xml:"Trigger"`
}

Triggers is a nested struct in qualitycheck response

type UpdateAsrVocabRequest ¶

type UpdateAsrVocabRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateAsrVocabRequest is the request struct for api UpdateAsrVocab

func CreateUpdateAsrVocabRequest ¶

func CreateUpdateAsrVocabRequest() (request *UpdateAsrVocabRequest)

CreateUpdateAsrVocabRequest creates a request to invoke UpdateAsrVocab API

type UpdateAsrVocabResponse ¶

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

UpdateAsrVocabResponse is the response struct for api UpdateAsrVocab

func CreateUpdateAsrVocabResponse ¶

func CreateUpdateAsrVocabResponse() (response *UpdateAsrVocabResponse)

CreateUpdateAsrVocabResponse creates a response to parse from UpdateAsrVocab response

type UpdateQualityCheckDataRequest ¶

type UpdateQualityCheckDataRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateQualityCheckDataRequest is the request struct for api UpdateQualityCheckData

func CreateUpdateQualityCheckDataRequest ¶

func CreateUpdateQualityCheckDataRequest() (request *UpdateQualityCheckDataRequest)

CreateUpdateQualityCheckDataRequest creates a request to invoke UpdateQualityCheckData API

type UpdateQualityCheckDataResponse ¶

type UpdateQualityCheckDataResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateQualityCheckDataResponse is the response struct for api UpdateQualityCheckData

func CreateUpdateQualityCheckDataResponse ¶

func CreateUpdateQualityCheckDataResponse() (response *UpdateQualityCheckDataResponse)

CreateUpdateQualityCheckDataResponse creates a response to parse from UpdateQualityCheckData response

type UpdateRuleRequest ¶

type UpdateRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateRuleRequest is the request struct for api UpdateRule

func CreateUpdateRuleRequest ¶

func CreateUpdateRuleRequest() (request *UpdateRuleRequest)

CreateUpdateRuleRequest creates a request to invoke UpdateRule API

type UpdateRuleResponse ¶

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

UpdateRuleResponse is the response struct for api UpdateRule

func CreateUpdateRuleResponse ¶

func CreateUpdateRuleResponse() (response *UpdateRuleResponse)

CreateUpdateRuleResponse creates a response to parse from UpdateRule response

type UpdateScoreForApiRequest ¶

type UpdateScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateScoreForApiRequest is the request struct for api UpdateScoreForApi

func CreateUpdateScoreForApiRequest ¶

func CreateUpdateScoreForApiRequest() (request *UpdateScoreForApiRequest)

CreateUpdateScoreForApiRequest creates a request to invoke UpdateScoreForApi API

type UpdateScoreForApiResponse ¶

type UpdateScoreForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateScoreForApiResponse is the response struct for api UpdateScoreForApi

func CreateUpdateScoreForApiResponse ¶

func CreateUpdateScoreForApiResponse() (response *UpdateScoreForApiResponse)

CreateUpdateScoreForApiResponse creates a response to parse from UpdateScoreForApi response

type UpdateSkillGroupConfigRequest ¶

type UpdateSkillGroupConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateSkillGroupConfigRequest is the request struct for api UpdateSkillGroupConfig

func CreateUpdateSkillGroupConfigRequest ¶

func CreateUpdateSkillGroupConfigRequest() (request *UpdateSkillGroupConfigRequest)

CreateUpdateSkillGroupConfigRequest creates a request to invoke UpdateSkillGroupConfig API

type UpdateSkillGroupConfigResponse ¶

type UpdateSkillGroupConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateSkillGroupConfigResponse is the response struct for api UpdateSkillGroupConfig

func CreateUpdateSkillGroupConfigResponse ¶

func CreateUpdateSkillGroupConfigResponse() (response *UpdateSkillGroupConfigResponse)

CreateUpdateSkillGroupConfigResponse creates a response to parse from UpdateSkillGroupConfig response

type UpdateSubScoreForApiRequest ¶

type UpdateSubScoreForApiRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateSubScoreForApiRequest is the request struct for api UpdateSubScoreForApi

func CreateUpdateSubScoreForApiRequest ¶

func CreateUpdateSubScoreForApiRequest() (request *UpdateSubScoreForApiRequest)

CreateUpdateSubScoreForApiRequest creates a request to invoke UpdateSubScoreForApi API

type UpdateSubScoreForApiResponse ¶

type UpdateSubScoreForApiResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateSubScoreForApiResponse is the response struct for api UpdateSubScoreForApi

func CreateUpdateSubScoreForApiResponse ¶

func CreateUpdateSubScoreForApiResponse() (response *UpdateSubScoreForApiResponse)

CreateUpdateSubScoreForApiResponse creates a response to parse from UpdateSubScoreForApi response

type UpdateSyncQualityCheckDataRequest ¶

type UpdateSyncQualityCheckDataRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateSyncQualityCheckDataRequest is the request struct for api UpdateSyncQualityCheckData

func CreateUpdateSyncQualityCheckDataRequest ¶

func CreateUpdateSyncQualityCheckDataRequest() (request *UpdateSyncQualityCheckDataRequest)

CreateUpdateSyncQualityCheckDataRequest creates a request to invoke UpdateSyncQualityCheckData API

type UpdateSyncQualityCheckDataResponse ¶

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

UpdateSyncQualityCheckDataResponse is the response struct for api UpdateSyncQualityCheckData

func CreateUpdateSyncQualityCheckDataResponse ¶

func CreateUpdateSyncQualityCheckDataResponse() (response *UpdateSyncQualityCheckDataResponse)

CreateUpdateSyncQualityCheckDataResponse creates a response to parse from UpdateSyncQualityCheckData response

type UpdateTaskAssignRuleRequest ¶

type UpdateTaskAssignRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateTaskAssignRuleRequest is the request struct for api UpdateTaskAssignRule

func CreateUpdateTaskAssignRuleRequest ¶

func CreateUpdateTaskAssignRuleRequest() (request *UpdateTaskAssignRuleRequest)

CreateUpdateTaskAssignRuleRequest creates a request to invoke UpdateTaskAssignRule API

type UpdateTaskAssignRuleResponse ¶

type UpdateTaskAssignRuleResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateTaskAssignRuleResponse is the response struct for api UpdateTaskAssignRule

func CreateUpdateTaskAssignRuleResponse ¶

func CreateUpdateTaskAssignRuleResponse() (response *UpdateTaskAssignRuleResponse)

CreateUpdateTaskAssignRuleResponse creates a response to parse from UpdateTaskAssignRule response

type UpdateUserConfigRequest ¶

type UpdateUserConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateUserConfigRequest is the request struct for api UpdateUserConfig

func CreateUpdateUserConfigRequest ¶

func CreateUpdateUserConfigRequest() (request *UpdateUserConfigRequest)

CreateUpdateUserConfigRequest creates a request to invoke UpdateUserConfig API

type UpdateUserConfigResponse ¶

type UpdateUserConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateUserConfigResponse is the response struct for api UpdateUserConfig

func CreateUpdateUserConfigResponse ¶

func CreateUpdateUserConfigResponse() (response *UpdateUserConfigResponse)

CreateUpdateUserConfigResponse creates a response to parse from UpdateUserConfig response

type UpdateUserRequest ¶

type UpdateUserRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateUserRequest is the request struct for api UpdateUser

func CreateUpdateUserRequest ¶

func CreateUpdateUserRequest() (request *UpdateUserRequest)

CreateUpdateUserRequest creates a request to invoke UpdateUser API

type UpdateUserResponse ¶

type UpdateUserResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateUserResponse is the response struct for api UpdateUser

func CreateUpdateUserResponse ¶

func CreateUpdateUserResponse() (response *UpdateUserResponse)

CreateUpdateUserResponse creates a response to parse from UpdateUser response

type UpdateWarningConfigRequest ¶

type UpdateWarningConfigRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UpdateWarningConfigRequest is the request struct for api UpdateWarningConfig

func CreateUpdateWarningConfigRequest ¶

func CreateUpdateWarningConfigRequest() (request *UpdateWarningConfigRequest)

CreateUpdateWarningConfigRequest creates a request to invoke UpdateWarningConfig API

type UpdateWarningConfigResponse ¶

type UpdateWarningConfigResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

UpdateWarningConfigResponse is the response struct for api UpdateWarningConfig

func CreateUpdateWarningConfigResponse ¶

func CreateUpdateWarningConfigResponse() (response *UpdateWarningConfigResponse)

CreateUpdateWarningConfigResponse creates a response to parse from UpdateWarningConfig response

type UploadAudioDataRequest ¶

type UploadAudioDataRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UploadAudioDataRequest is the request struct for api UploadAudioData

func CreateUploadAudioDataRequest ¶

func CreateUploadAudioDataRequest() (request *UploadAudioDataRequest)

CreateUploadAudioDataRequest creates a request to invoke UploadAudioData API

type UploadAudioDataResponse ¶

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

UploadAudioDataResponse is the response struct for api UploadAudioData

func CreateUploadAudioDataResponse ¶

func CreateUploadAudioDataResponse() (response *UploadAudioDataResponse)

CreateUploadAudioDataResponse creates a response to parse from UploadAudioData response

type UploadDataRequest ¶

type UploadDataRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UploadDataRequest is the request struct for api UploadData

func CreateUploadDataRequest ¶

func CreateUploadDataRequest() (request *UploadDataRequest)

CreateUploadDataRequest creates a request to invoke UploadData API

type UploadDataResponse ¶

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

UploadDataResponse is the response struct for api UploadData

func CreateUploadDataResponse ¶

func CreateUploadDataResponse() (response *UploadDataResponse)

CreateUploadDataResponse creates a response to parse from UploadData response

type UploadDataSyncRequest ¶

type UploadDataSyncRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UploadDataSyncRequest is the request struct for api UploadDataSync

func CreateUploadDataSyncRequest ¶

func CreateUploadDataSyncRequest() (request *UploadDataSyncRequest)

CreateUploadDataSyncRequest creates a request to invoke UploadDataSync API

type UploadDataSyncResponse ¶

type UploadDataSyncResponse struct {
	*responses.BaseResponse
	Code      string               `json:"Code" xml:"Code"`
	Message   string               `json:"Message" xml:"Message"`
	RequestId string               `json:"RequestId" xml:"RequestId"`
	Success   bool                 `json:"Success" xml:"Success"`
	Data      DataInUploadDataSync `json:"Data" xml:"Data"`
}

UploadDataSyncResponse is the response struct for api UploadDataSync

func CreateUploadDataSyncResponse ¶

func CreateUploadDataSyncResponse() (response *UploadDataSyncResponse)

CreateUploadDataSyncResponse creates a response to parse from UploadDataSync response

type UploadRuleRequest ¶

type UploadRuleRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

UploadRuleRequest is the request struct for api UploadRule

func CreateUploadRuleRequest ¶

func CreateUploadRuleRequest() (request *UploadRuleRequest)

CreateUploadRuleRequest creates a request to invoke UploadRule API

type UploadRuleResponse ¶

type UploadRuleResponse struct {
	*responses.BaseResponse
	Code      string           `json:"Code" xml:"Code"`
	Message   string           `json:"Message" xml:"Message"`
	RequestId string           `json:"RequestId" xml:"RequestId"`
	Success   bool             `json:"Success" xml:"Success"`
	Data      DataInUploadRule `json:"Data" xml:"Data"`
}

UploadRuleResponse is the response struct for api UploadRule

func CreateUploadRuleResponse ¶

func CreateUploadRuleResponse() (response *UploadRuleResponse)

CreateUploadRuleResponse creates a response to parse from UploadRule response

type User ¶

type User struct {
	DisplayName   string `json:"DisplayName" xml:"DisplayName"`
	UpdateTime    string `json:"UpdateTime" xml:"UpdateTime"`
	Description   string `json:"Description" xml:"Description"`
	CreateTime    string `json:"CreateTime" xml:"CreateTime"`
	LoginUserType int    `json:"LoginUserType" xml:"LoginUserType"`
	AliUid        string `json:"AliUid" xml:"AliUid"`
	RoleName      string `json:"RoleName" xml:"RoleName"`
	UserName      string `json:"UserName" xml:"UserName"`
	Id            int64  `json:"Id" xml:"Id"`
}

User is a nested struct in qualitycheck response

type VerifyFileRequest ¶

type VerifyFileRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

VerifyFileRequest is the request struct for api VerifyFile

func CreateVerifyFileRequest ¶

func CreateVerifyFileRequest() (request *VerifyFileRequest)

CreateVerifyFileRequest creates a request to invoke VerifyFile API

type VerifyFileResponse ¶

type VerifyFileResponse struct {
	*responses.BaseResponse
	Code      string  `json:"Code" xml:"Code"`
	Message   string  `json:"Message" xml:"Message"`
	Data      float64 `json:"Data" xml:"Data"`
	RequestId string  `json:"RequestId" xml:"RequestId"`
	Success   bool    `json:"Success" xml:"Success"`
}

VerifyFileResponse is the response struct for api VerifyFile

func CreateVerifyFileResponse ¶

func CreateVerifyFileResponse() (response *VerifyFileResponse)

CreateVerifyFileResponse creates a response to parse from VerifyFile response

type VerifySentenceRequest ¶

type VerifySentenceRequest struct {
	*requests.RpcRequest
	ResourceOwnerId requests.Integer `position:"Query" name:"ResourceOwnerId"`
	JsonStr         string           `position:"Query" name:"JsonStr"`
}

VerifySentenceRequest is the request struct for api VerifySentence

func CreateVerifySentenceRequest ¶

func CreateVerifySentenceRequest() (request *VerifySentenceRequest)

CreateVerifySentenceRequest creates a request to invoke VerifySentence API

type VerifySentenceResponse ¶

type VerifySentenceResponse struct {
	*responses.BaseResponse
	RequestId      string               `json:"RequestId" xml:"RequestId"`
	Success        bool                 `json:"Success" xml:"Success"`
	IncorrectWords int                  `json:"IncorrectWords" xml:"IncorrectWords"`
	TargetRole     int                  `json:"TargetRole" xml:"TargetRole"`
	Code           string               `json:"Code" xml:"Code"`
	Message        string               `json:"Message" xml:"Message"`
	SourceRole     int                  `json:"SourceRole" xml:"SourceRole"`
	Data           DataInVerifySentence `json:"Data" xml:"Data"`
}

VerifySentenceResponse is the response struct for api VerifySentence

func CreateVerifySentenceResponse ¶

func CreateVerifySentenceResponse() (response *VerifySentenceResponse)

CreateVerifySentenceResponse creates a response to parse from VerifySentence response

type WarningConfigInfo ¶

type WarningConfigInfo struct {
	Status     int                         `json:"Status" xml:"Status"`
	ConfigName string                      `json:"ConfigName" xml:"ConfigName"`
	UpdateTime string                      `json:"UpdateTime" xml:"UpdateTime"`
	ConfigId   int64                       `json:"ConfigId" xml:"ConfigId"`
	CreateTime string                      `json:"CreateTime" xml:"CreateTime"`
	RidList    RidList                     `json:"RidList" xml:"RidList"`
	RuleList   RuleListInListWarningConfig `json:"RuleList" xml:"RuleList"`
	Channels   Channels                    `json:"Channels" xml:"Channels"`
}

WarningConfigInfo is a nested struct in qualitycheck response

type WarningRule ¶

type WarningRule struct {
	RuleName string `json:"RuleName" xml:"RuleName"`
	Rid      int64  `json:"Rid" xml:"Rid"`
}

WarningRule is a nested struct in qualitycheck response

type Word ¶

type Word struct {
	Weight int    `json:"Weight" xml:"Weight"`
	Word   string `json:"Word" xml:"Word"`
}

Word is a nested struct in qualitycheck response

type Words ¶

type Words struct {
	Word []Word `json:"Word" xml:"Word"`
}

Words is a nested struct in qualitycheck response

type WordsParam ¶

type WordsParam struct {
	Excludes      string `json:"Excludes" xml:"Excludes"`
	Includes      string `json:"Includes" xml:"Includes"`
	ExtraConfigId int64  `json:"ExtraConfigId" xml:"ExtraConfigId"`
}

WordsParam is a nested struct in qualitycheck response

Source Files ¶

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL