// Copyright (c) 2017-2025 Tencent. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package v20200210

import (
    "context"
    "errors"
    "github.com/tencentcloud/tencentcloud-sdk-go-intl-en/tencentcloud/common"
    tchttp "github.com/tencentcloud/tencentcloud-sdk-go-intl-en/tencentcloud/common/http"
    "github.com/tencentcloud/tencentcloud-sdk-go-intl-en/tencentcloud/common/profile"
)

const APIVersion = "2020-02-10"

type Client struct {
    common.Client
}

// Deprecated
func NewClientWithSecretId(secretId, secretKey, region string) (client *Client, err error) {
    cpf := profile.NewClientProfile()
    client = &Client{}
    client.Init(region).WithSecretId(secretId, secretKey).WithProfile(cpf)
    return
}

func NewClient(credential common.CredentialIface, region string, clientProfile *profile.ClientProfile) (client *Client, err error) {
    client = &Client{}
    client.Init(region).
        WithCredential(credential).
        WithProfile(clientProfile)
    return
}


func NewAbortAgentCruiseDialingCampaignRequest() (request *AbortAgentCruiseDialingCampaignRequest) {
    request = &AbortAgentCruiseDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "AbortAgentCruiseDialingCampaign")
    
    
    return
}

func NewAbortAgentCruiseDialingCampaignResponse() (response *AbortAgentCruiseDialingCampaignResponse) {
    response = &AbortAgentCruiseDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// AbortAgentCruiseDialingCampaign
// Stop Agent Cruise-style Outbound Call Task
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) AbortAgentCruiseDialingCampaign(request *AbortAgentCruiseDialingCampaignRequest) (response *AbortAgentCruiseDialingCampaignResponse, err error) {
    return c.AbortAgentCruiseDialingCampaignWithContext(context.Background(), request)
}

// AbortAgentCruiseDialingCampaign
// Stop Agent Cruise-style Outbound Call Task
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) AbortAgentCruiseDialingCampaignWithContext(ctx context.Context, request *AbortAgentCruiseDialingCampaignRequest) (response *AbortAgentCruiseDialingCampaignResponse, err error) {
    if request == nil {
        request = NewAbortAgentCruiseDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "AbortAgentCruiseDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("AbortAgentCruiseDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewAbortAgentCruiseDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewAbortPredictiveDialingCampaignRequest() (request *AbortPredictiveDialingCampaignRequest) {
    request = &AbortPredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "AbortPredictiveDialingCampaign")
    
    
    return
}

func NewAbortPredictiveDialingCampaignResponse() (response *AbortPredictiveDialingCampaignResponse) {
    response = &AbortPredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// AbortPredictiveDialingCampaign
// This API is used to pause the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) AbortPredictiveDialingCampaign(request *AbortPredictiveDialingCampaignRequest) (response *AbortPredictiveDialingCampaignResponse, err error) {
    return c.AbortPredictiveDialingCampaignWithContext(context.Background(), request)
}

// AbortPredictiveDialingCampaign
// This API is used to pause the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) AbortPredictiveDialingCampaignWithContext(ctx context.Context, request *AbortPredictiveDialingCampaignRequest) (response *AbortPredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewAbortPredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "AbortPredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("AbortPredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewAbortPredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewBindNumberCallInInterfaceRequest() (request *BindNumberCallInInterfaceRequest) {
    request = &BindNumberCallInInterfaceRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "BindNumberCallInInterface")
    
    
    return
}

func NewBindNumberCallInInterfaceResponse() (response *BindNumberCallInInterfaceResponse) {
    response = &BindNumberCallInInterfaceResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// BindNumberCallInInterface
// This API is used to bind a number to a callback API for incoming calls.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) BindNumberCallInInterface(request *BindNumberCallInInterfaceRequest) (response *BindNumberCallInInterfaceResponse, err error) {
    return c.BindNumberCallInInterfaceWithContext(context.Background(), request)
}

// BindNumberCallInInterface
// This API is used to bind a number to a callback API for incoming calls.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) BindNumberCallInInterfaceWithContext(ctx context.Context, request *BindNumberCallInInterfaceRequest) (response *BindNumberCallInInterfaceResponse, err error) {
    if request == nil {
        request = NewBindNumberCallInInterfaceRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "BindNumberCallInInterface")
    
    if c.GetCredential() == nil {
        return nil, errors.New("BindNumberCallInInterface require credential")
    }

    request.SetContext(ctx)
    
    response = NewBindNumberCallInInterfaceResponse()
    err = c.Send(request, response)
    return
}

func NewBindNumberCallOutSkillGroupRequest() (request *BindNumberCallOutSkillGroupRequest) {
    request = &BindNumberCallOutSkillGroupRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "BindNumberCallOutSkillGroup")
    
    
    return
}

func NewBindNumberCallOutSkillGroupResponse() (response *BindNumberCallOutSkillGroupResponse) {
    response = &BindNumberCallOutSkillGroupResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// BindNumberCallOutSkillGroup
// This API is used to bind outbound skill group of number.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) BindNumberCallOutSkillGroup(request *BindNumberCallOutSkillGroupRequest) (response *BindNumberCallOutSkillGroupResponse, err error) {
    return c.BindNumberCallOutSkillGroupWithContext(context.Background(), request)
}

// BindNumberCallOutSkillGroup
// This API is used to bind outbound skill group of number.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) BindNumberCallOutSkillGroupWithContext(ctx context.Context, request *BindNumberCallOutSkillGroupRequest) (response *BindNumberCallOutSkillGroupResponse, err error) {
    if request == nil {
        request = NewBindNumberCallOutSkillGroupRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "BindNumberCallOutSkillGroup")
    
    if c.GetCredential() == nil {
        return nil, errors.New("BindNumberCallOutSkillGroup require credential")
    }

    request.SetContext(ctx)
    
    response = NewBindNumberCallOutSkillGroupResponse()
    err = c.Send(request, response)
    return
}

func NewBindStaffSkillGroupListRequest() (request *BindStaffSkillGroupListRequest) {
    request = &BindStaffSkillGroupListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "BindStaffSkillGroupList")
    
    
    return
}

func NewBindStaffSkillGroupListResponse() (response *BindStaffSkillGroupListResponse) {
    response = &BindStaffSkillGroupListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// BindStaffSkillGroupList
// This API is used to bind the agent's skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) BindStaffSkillGroupList(request *BindStaffSkillGroupListRequest) (response *BindStaffSkillGroupListResponse, err error) {
    return c.BindStaffSkillGroupListWithContext(context.Background(), request)
}

// BindStaffSkillGroupList
// This API is used to bind the agent's skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) BindStaffSkillGroupListWithContext(ctx context.Context, request *BindStaffSkillGroupListRequest) (response *BindStaffSkillGroupListResponse, err error) {
    if request == nil {
        request = NewBindStaffSkillGroupListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "BindStaffSkillGroupList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("BindStaffSkillGroupList require credential")
    }

    request.SetContext(ctx)
    
    response = NewBindStaffSkillGroupListResponse()
    err = c.Send(request, response)
    return
}

func NewControlAIConversationRequest() (request *ControlAIConversationRequest) {
    request = &ControlAIConversationRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ControlAIConversation")
    
    
    return
}

func NewControlAIConversationResponse() (response *ControlAIConversationResponse) {
    response = &ControlAIConversationResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ControlAIConversation
// This API is used to provide server-side robot control feature.
//
// error code that may be returned:
//  FAILEDOPERATION_CONTROLAICONVERSATION = "FailedOperation.ControlAIConversation"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ControlAIConversation(request *ControlAIConversationRequest) (response *ControlAIConversationResponse, err error) {
    return c.ControlAIConversationWithContext(context.Background(), request)
}

// ControlAIConversation
// This API is used to provide server-side robot control feature.
//
// error code that may be returned:
//  FAILEDOPERATION_CONTROLAICONVERSATION = "FailedOperation.ControlAIConversation"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ControlAIConversationWithContext(ctx context.Context, request *ControlAIConversationRequest) (response *ControlAIConversationResponse, err error) {
    if request == nil {
        request = NewControlAIConversationRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ControlAIConversation")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ControlAIConversation require credential")
    }

    request.SetContext(ctx)
    
    response = NewControlAIConversationResponse()
    err = c.Send(request, response)
    return
}

func NewCreateAIAgentCallRequest() (request *CreateAIAgentCallRequest) {
    request = &CreateAIAgentCallRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateAIAgentCall")
    
    
    return
}

func NewCreateAIAgentCallResponse() (response *CreateAIAgentCallResponse) {
    response = &CreateAIAgentCallResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateAIAgentCall
// Used to create one-time Intelligent Agent outbound calls. You can create a voice Intelligent Agent in the management console - Intelligent Agent Management and perform dialogue process configuration (https://www.tencentcloud.com/document/product/679/119796?from_cn_redirect=1). This API is used to initiate a single outbound call task with a configured Intelligent Agent. To create batch Intelligent Agent outbound call tasks, refer to the documentation for creating automatic outbound call tasks (https://www.tencentcloud.com/document/product/679/69194?from_cn_redirect=1).
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone number. For details, refer to the [Intelligent Agent Call Purchase Guide](https://www.tencentcloud.com/document/product/1229/59535?from_cn_redirect=1).
//
// error code that may be returned:
//  FAILEDOPERATION_AILICENSEHASEXPIRED = "FailedOperation.AILicenseHasExpired"
//  FAILEDOPERATION_ACQUIREQUOTA = "FailedOperation.AcquireQuota"
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAIAgentCall(request *CreateAIAgentCallRequest) (response *CreateAIAgentCallResponse, err error) {
    return c.CreateAIAgentCallWithContext(context.Background(), request)
}

// CreateAIAgentCall
// Used to create one-time Intelligent Agent outbound calls. You can create a voice Intelligent Agent in the management console - Intelligent Agent Management and perform dialogue process configuration (https://www.tencentcloud.com/document/product/679/119796?from_cn_redirect=1). This API is used to initiate a single outbound call task with a configured Intelligent Agent. To create batch Intelligent Agent outbound call tasks, refer to the documentation for creating automatic outbound call tasks (https://www.tencentcloud.com/document/product/679/69194?from_cn_redirect=1).
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone number. For details, refer to the [Intelligent Agent Call Purchase Guide](https://www.tencentcloud.com/document/product/1229/59535?from_cn_redirect=1).
//
// error code that may be returned:
//  FAILEDOPERATION_AILICENSEHASEXPIRED = "FailedOperation.AILicenseHasExpired"
//  FAILEDOPERATION_ACQUIREQUOTA = "FailedOperation.AcquireQuota"
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAIAgentCallWithContext(ctx context.Context, request *CreateAIAgentCallRequest) (response *CreateAIAgentCallResponse, err error) {
    if request == nil {
        request = NewCreateAIAgentCallRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateAIAgentCall")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateAIAgentCall require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateAIAgentCallResponse()
    err = c.Send(request, response)
    return
}

func NewCreateAICallRequest() (request *CreateAICallRequest) {
    request = &CreateAICallRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateAICall")
    
    
    return
}

func NewCreateAICallResponse() (response *CreateAICallResponse) {
    response = &CreateAICallResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateAICall
// This API is used to **call the AI model directly** to trigger a **single** outbound call. It supports configuring the model, prompt content, voice, and all call elements through API parameters.
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone numbers. For details, refer to the [Intelligent Agent Call Purchase Guide](https://www.tencentcloud.com/document/product/1229/59535?from_cn_redirect=1).
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAICall(request *CreateAICallRequest) (response *CreateAICallResponse, err error) {
    return c.CreateAICallWithContext(context.Background(), request)
}

// CreateAICall
// This API is used to **call the AI model directly** to trigger a **single** outbound call. It supports configuring the model, prompt content, voice, and all call elements through API parameters.
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone numbers. For details, refer to the [Intelligent Agent Call Purchase Guide](https://www.tencentcloud.com/document/product/1229/59535?from_cn_redirect=1).
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAICallWithContext(ctx context.Context, request *CreateAICallRequest) (response *CreateAICallResponse, err error) {
    if request == nil {
        request = NewCreateAICallRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateAICall")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateAICall require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateAICallResponse()
    err = c.Send(request, response)
    return
}

func NewCreateAdminURLRequest() (request *CreateAdminURLRequest) {
    request = &CreateAdminURLRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateAdminURL")
    
    
    return
}

func NewCreateAdminURLResponse() (response *CreateAdminURLResponse) {
    response = &CreateAdminURLResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateAdminURL
// This API is used to create a management access link.
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAdminURL(request *CreateAdminURLRequest) (response *CreateAdminURLResponse, err error) {
    return c.CreateAdminURLWithContext(context.Background(), request)
}

// CreateAdminURL
// This API is used to create a management access link.
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateAdminURLWithContext(ctx context.Context, request *CreateAdminURLRequest) (response *CreateAdminURLResponse, err error) {
    if request == nil {
        request = NewCreateAdminURLRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateAdminURL")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateAdminURL require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateAdminURLResponse()
    err = c.Send(request, response)
    return
}

func NewCreateAgentCruiseDialingCampaignRequest() (request *CreateAgentCruiseDialingCampaignRequest) {
    request = &CreateAgentCruiseDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateAgentCruiseDialingCampaign")
    
    
    return
}

func NewCreateAgentCruiseDialingCampaignResponse() (response *CreateAgentCruiseDialingCampaignResponse) {
    response = &CreateAgentCruiseDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateAgentCruiseDialingCampaign
// Agent Cruise-style Outbound Call.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) CreateAgentCruiseDialingCampaign(request *CreateAgentCruiseDialingCampaignRequest) (response *CreateAgentCruiseDialingCampaignResponse, err error) {
    return c.CreateAgentCruiseDialingCampaignWithContext(context.Background(), request)
}

// CreateAgentCruiseDialingCampaign
// Agent Cruise-style Outbound Call.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) CreateAgentCruiseDialingCampaignWithContext(ctx context.Context, request *CreateAgentCruiseDialingCampaignRequest) (response *CreateAgentCruiseDialingCampaignResponse, err error) {
    if request == nil {
        request = NewCreateAgentCruiseDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateAgentCruiseDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateAgentCruiseDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateAgentCruiseDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewCreateAutoCalloutTaskRequest() (request *CreateAutoCalloutTaskRequest) {
    request = &CreateAutoCalloutTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateAutoCalloutTask")
    
    
    return
}

func NewCreateAutoCalloutTaskResponse() (response *CreateAutoCalloutTaskResponse) {
    response = &CreateAutoCalloutTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateAutoCalloutTask
// This API is used to create bulk automatic outbound calls. The system will automatically initiate outbound calls to the designated called number list based on task configuration. This API can call the configured Intelligent Agent to perform batch outbound call tasks. You can create a voice Intelligent Agent in the management console-Intelligent Agent Management and configure the dialogue process (https://www.tencentcloud.com/document/product/679/119796?from_cn_redirect=1). To create a single Intelligent Agent outbound call task, refer to the documentation (https://www.tencentcloud.com/document/product/679/115681?from_cn_redirect=1).
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone number.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_EXPERIENCEACCOUNT = "InvalidParameterValue.ExperienceAccount"
func (c *Client) CreateAutoCalloutTask(request *CreateAutoCalloutTaskRequest) (response *CreateAutoCalloutTaskResponse, err error) {
    return c.CreateAutoCalloutTaskWithContext(context.Background(), request)
}

// CreateAutoCalloutTask
// This API is used to create bulk automatic outbound calls. The system will automatically initiate outbound calls to the designated called number list based on task configuration. This API can call the configured Intelligent Agent to perform batch outbound call tasks. You can create a voice Intelligent Agent in the management console-Intelligent Agent Management and configure the dialogue process (https://www.tencentcloud.com/document/product/679/119796?from_cn_redirect=1). To create a single Intelligent Agent outbound call task, refer to the documentation (https://www.tencentcloud.com/document/product/679/115681?from_cn_redirect=1).
//
// 
//
// The feature requires purchase of the Intelligent Agent call package and is only available for own telephone number.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_EXPERIENCEACCOUNT = "InvalidParameterValue.ExperienceAccount"
func (c *Client) CreateAutoCalloutTaskWithContext(ctx context.Context, request *CreateAutoCalloutTaskRequest) (response *CreateAutoCalloutTaskResponse, err error) {
    if request == nil {
        request = NewCreateAutoCalloutTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateAutoCalloutTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateAutoCalloutTask require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateAutoCalloutTaskResponse()
    err = c.Send(request, response)
    return
}

func NewCreateCCCSkillGroupRequest() (request *CreateCCCSkillGroupRequest) {
    request = &CreateCCCSkillGroupRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateCCCSkillGroup")
    
    
    return
}

func NewCreateCCCSkillGroupResponse() (response *CreateCCCSkillGroupResponse) {
    response = &CreateCCCSkillGroupResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateCCCSkillGroup
// This API is used to create a new skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_SKILLGROUPEXIST = "InvalidParameterValue.SkillGroupExist"
func (c *Client) CreateCCCSkillGroup(request *CreateCCCSkillGroupRequest) (response *CreateCCCSkillGroupResponse, err error) {
    return c.CreateCCCSkillGroupWithContext(context.Background(), request)
}

// CreateCCCSkillGroup
// This API is used to create a new skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_SKILLGROUPEXIST = "InvalidParameterValue.SkillGroupExist"
func (c *Client) CreateCCCSkillGroupWithContext(ctx context.Context, request *CreateCCCSkillGroupRequest) (response *CreateCCCSkillGroupResponse, err error) {
    if request == nil {
        request = NewCreateCCCSkillGroupRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateCCCSkillGroup")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateCCCSkillGroup require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateCCCSkillGroupResponse()
    err = c.Send(request, response)
    return
}

func NewCreateCallOutSessionRequest() (request *CreateCallOutSessionRequest) {
    request = &CreateCallOutSessionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateCallOutSession")
    
    
    return
}

func NewCreateCallOutSessionResponse() (response *CreateCallOutSessionResponse) {
    response = &CreateCallOutSessionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateCallOutSession
// This API is used to create an outbound call session. Currently, only dual calls are supported. That is, first use the platform number to call the agent mobile phone. After the agent answers, then make an outbound call to the user. Moreover, due to ISP frequency restrictions, the agent phone number must be added to the allowlist first to avoid frequency control leading to the failure of the outbound call. Therefore, before calling this API, the following operations have been completed.
//
// 1. The agent specified by UserId has already bound the mobile number. https://intl.cloud.tencent.com/document/product/679/76067?from_cn_redirect=1#.E6.AD.A5.E9.AA.A42.EF.BC.9A.E5.AE.8C.E5.96.84.E8.B4.A6.E5.8F.B7.E4.BF.A1.E6.81.AF.
//
// 2. The agent's bound mobile number has applied for and passed the outbound call allowlist.
//
// This API is used to make calls. Currently, the agent side can only call the user's mobile phone, so the IsForceMobile field must be true.
//
// 4. Do not fill in the mobile number bound to the current UserId for the callee, otherwise it can lead to call failure due to a busy line.
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISLIMITED = "FailedOperation.CalleeIsLimited"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_SEATSTATUSBUSY = "FailedOperation.SeatStatusBusy"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  OPERATIONDENIED_NOTINWHITELIST = "OperationDenied.NotInWhiteList"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateCallOutSession(request *CreateCallOutSessionRequest) (response *CreateCallOutSessionResponse, err error) {
    return c.CreateCallOutSessionWithContext(context.Background(), request)
}

// CreateCallOutSession
// This API is used to create an outbound call session. Currently, only dual calls are supported. That is, first use the platform number to call the agent mobile phone. After the agent answers, then make an outbound call to the user. Moreover, due to ISP frequency restrictions, the agent phone number must be added to the allowlist first to avoid frequency control leading to the failure of the outbound call. Therefore, before calling this API, the following operations have been completed.
//
// 1. The agent specified by UserId has already bound the mobile number. https://intl.cloud.tencent.com/document/product/679/76067?from_cn_redirect=1#.E6.AD.A5.E9.AA.A42.EF.BC.9A.E5.AE.8C.E5.96.84.E8.B4.A6.E5.8F.B7.E4.BF.A1.E6.81.AF.
//
// 2. The agent's bound mobile number has applied for and passed the outbound call allowlist.
//
// This API is used to make calls. Currently, the agent side can only call the user's mobile phone, so the IsForceMobile field must be true.
//
// 4. Do not fill in the mobile number bound to the current UserId for the callee, otherwise it can lead to call failure due to a busy line.
//
// error code that may be returned:
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISLIMITED = "FailedOperation.CalleeIsLimited"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_SEATSTATUSBUSY = "FailedOperation.SeatStatusBusy"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  OPERATIONDENIED_NOTINWHITELIST = "OperationDenied.NotInWhiteList"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateCallOutSessionWithContext(ctx context.Context, request *CreateCallOutSessionRequest) (response *CreateCallOutSessionResponse, err error) {
    if request == nil {
        request = NewCreateCallOutSessionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateCallOutSession")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateCallOutSession require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateCallOutSessionResponse()
    err = c.Send(request, response)
    return
}

func NewCreateExtensionRequest() (request *CreateExtensionRequest) {
    request = &CreateExtensionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateExtension")
    
    
    return
}

func NewCreateExtensionResponse() (response *CreateExtensionResponse) {
    response = &CreateExtensionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateExtension
// This API is used to create the telephone account.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) CreateExtension(request *CreateExtensionRequest) (response *CreateExtensionResponse, err error) {
    return c.CreateExtensionWithContext(context.Background(), request)
}

// CreateExtension
// This API is used to create the telephone account.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) CreateExtensionWithContext(ctx context.Context, request *CreateExtensionRequest) (response *CreateExtensionResponse, err error) {
    if request == nil {
        request = NewCreateExtensionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateExtension")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateExtension require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateExtensionResponse()
    err = c.Send(request, response)
    return
}

func NewCreateIVRSessionRequest() (request *CreateIVRSessionRequest) {
    request = &CreateIVRSessionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateIVRSession")
    
    
    return
}

func NewCreateIVRSessionResponse() (response *CreateIVRSessionResponse) {
    response = &CreateIVRSessionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateIVRSession
// Create a session associated with IVR. This feature is supported only in the Advanced Version. Currently, it supports inbound and automatic outbound IVR types. Upon receiving the request, TCCC will first attempt to call the callee, then enter the IVR flow.
//
// error code that may be returned:
//  FAILEDOPERATION_AICONCURRENTNOPACKAGE = "FailedOperation.AIConcurrentNoPackage"
//  FAILEDOPERATION_AICONCURRENTOVERFREQUENCY = "FailedOperation.AIConcurrentOverFrequency"
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateIVRSession(request *CreateIVRSessionRequest) (response *CreateIVRSessionResponse, err error) {
    return c.CreateIVRSessionWithContext(context.Background(), request)
}

// CreateIVRSession
// Create a session associated with IVR. This feature is supported only in the Advanced Version. Currently, it supports inbound and automatic outbound IVR types. Upon receiving the request, TCCC will first attempt to call the callee, then enter the IVR flow.
//
// error code that may be returned:
//  FAILEDOPERATION_AICONCURRENTNOPACKAGE = "FailedOperation.AIConcurrentNoPackage"
//  FAILEDOPERATION_AICONCURRENTOVERFREQUENCY = "FailedOperation.AIConcurrentOverFrequency"
//  FAILEDOPERATION_CALLOUTFAILED = "FailedOperation.CallOutFailed"
//  FAILEDOPERATION_CALLEEISBLACKUSER = "FailedOperation.CalleeIsBlackUser"
//  FAILEDOPERATION_CALLEROVERFREQUENCY = "FailedOperation.CallerOverFrequency"
//  FAILEDOPERATION_CALLOUTRULEBLINDAREA = "FailedOperation.CalloutRuleBlindArea"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEINTERVALTIME = "FailedOperation.CalloutRuleMaxCallCountCalleeIntervalTime"
//  FAILEDOPERATION_CALLOUTRULEMAXCALLCOUNTCALLEEPERDAYAPPID = "FailedOperation.CalloutRuleMaxCallCountCalleePerDayAppID"
//  FAILEDOPERATION_CALLOUTRULENOTWORKTIME = "FailedOperation.CalloutRuleNotWorkTime"
//  FAILEDOPERATION_NOCALLOUTNUMBER = "FailedOperation.NoCallOutNumber"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED_BASEPACKAGEEXPIRED = "LimitExceeded.BasePackageExpired"
func (c *Client) CreateIVRSessionWithContext(ctx context.Context, request *CreateIVRSessionRequest) (response *CreateIVRSessionResponse, err error) {
    if request == nil {
        request = NewCreateIVRSessionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateIVRSession")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateIVRSession require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateIVRSessionResponse()
    err = c.Send(request, response)
    return
}

func NewCreateOwnNumberApplyRequest() (request *CreateOwnNumberApplyRequest) {
    request = &CreateOwnNumberApplyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateOwnNumberApply")
    
    
    return
}

func NewCreateOwnNumberApplyResponse() (response *CreateOwnNumberApplyResponse) {
    response = &CreateOwnNumberApplyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateOwnNumberApply
// Create customer's own number access review
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_APPLYIDNOTEXIST = "InvalidParameterValue.ApplyIDNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMINVALID = "InvalidParameterValue.PhoneNumInvalid"
//  INVALIDPARAMETERVALUE_WAITINGAPPROVALOVERFLOW = "InvalidParameterValue.WaitingApprovalOverflow"
func (c *Client) CreateOwnNumberApply(request *CreateOwnNumberApplyRequest) (response *CreateOwnNumberApplyResponse, err error) {
    return c.CreateOwnNumberApplyWithContext(context.Background(), request)
}

// CreateOwnNumberApply
// Create customer's own number access review
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_APPLYIDNOTEXIST = "InvalidParameterValue.ApplyIDNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMINVALID = "InvalidParameterValue.PhoneNumInvalid"
//  INVALIDPARAMETERVALUE_WAITINGAPPROVALOVERFLOW = "InvalidParameterValue.WaitingApprovalOverflow"
func (c *Client) CreateOwnNumberApplyWithContext(ctx context.Context, request *CreateOwnNumberApplyRequest) (response *CreateOwnNumberApplyResponse, err error) {
    if request == nil {
        request = NewCreateOwnNumberApplyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateOwnNumberApply")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateOwnNumberApply require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateOwnNumberApplyResponse()
    err = c.Send(request, response)
    return
}

func NewCreatePredictiveDialingCampaignRequest() (request *CreatePredictiveDialingCampaignRequest) {
    request = &CreatePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreatePredictiveDialingCampaign")
    
    
    return
}

func NewCreatePredictiveDialingCampaignResponse() (response *CreatePredictiveDialingCampaignResponse) {
    response = &CreatePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreatePredictiveDialingCampaign
// This API is used to create the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) CreatePredictiveDialingCampaign(request *CreatePredictiveDialingCampaignRequest) (response *CreatePredictiveDialingCampaignResponse, err error) {
    return c.CreatePredictiveDialingCampaignWithContext(context.Background(), request)
}

// CreatePredictiveDialingCampaign
// This API is used to create the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) CreatePredictiveDialingCampaignWithContext(ctx context.Context, request *CreatePredictiveDialingCampaignRequest) (response *CreatePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewCreatePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreatePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreatePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreatePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewCreateSDKLoginTokenRequest() (request *CreateSDKLoginTokenRequest) {
    request = &CreateSDKLoginTokenRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateSDKLoginToken")
    
    
    return
}

func NewCreateSDKLoginTokenResponse() (response *CreateSDKLoginTokenResponse) {
    response = &CreateSDKLoginTokenResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateSDKLoginToken
// This API is used to create the SDK log-in token.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  OPERATIONDENIED_UINDISABLED = "OperationDenied.UinDisabled"
func (c *Client) CreateSDKLoginToken(request *CreateSDKLoginTokenRequest) (response *CreateSDKLoginTokenResponse, err error) {
    return c.CreateSDKLoginTokenWithContext(context.Background(), request)
}

// CreateSDKLoginToken
// This API is used to create the SDK log-in token.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  OPERATIONDENIED_UINDISABLED = "OperationDenied.UinDisabled"
func (c *Client) CreateSDKLoginTokenWithContext(ctx context.Context, request *CreateSDKLoginTokenRequest) (response *CreateSDKLoginTokenResponse, err error) {
    if request == nil {
        request = NewCreateSDKLoginTokenRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateSDKLoginToken")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateSDKLoginToken require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateSDKLoginTokenResponse()
    err = c.Send(request, response)
    return
}

func NewCreateStaffRequest() (request *CreateStaffRequest) {
    request = &CreateStaffRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateStaff")
    
    
    return
}

func NewCreateStaffResponse() (response *CreateStaffResponse) {
    response = &CreateStaffResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateStaff
// This API is used to create the customer service account.
//
// error code that may be returned:
//  FAILEDOPERATION_DUPLICATEDACCOUNT = "FailedOperation.DuplicatedAccount"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED = "LimitExceeded"
func (c *Client) CreateStaff(request *CreateStaffRequest) (response *CreateStaffResponse, err error) {
    return c.CreateStaffWithContext(context.Background(), request)
}

// CreateStaff
// This API is used to create the customer service account.
//
// error code that may be returned:
//  FAILEDOPERATION_DUPLICATEDACCOUNT = "FailedOperation.DuplicatedAccount"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  LIMITEXCEEDED = "LimitExceeded"
func (c *Client) CreateStaffWithContext(ctx context.Context, request *CreateStaffRequest) (response *CreateStaffResponse, err error) {
    if request == nil {
        request = NewCreateStaffRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateStaff")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateStaff require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateStaffResponse()
    err = c.Send(request, response)
    return
}

func NewCreateUserSigRequest() (request *CreateUserSigRequest) {
    request = &CreateUserSigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "CreateUserSig")
    
    
    return
}

func NewCreateUserSigResponse() (response *CreateUserSigResponse) {
    response = &CreateUserSigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateUserSig
// This API is used to create a user data signature.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) CreateUserSig(request *CreateUserSigRequest) (response *CreateUserSigResponse, err error) {
    return c.CreateUserSigWithContext(context.Background(), request)
}

// CreateUserSig
// This API is used to create a user data signature.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) CreateUserSigWithContext(ctx context.Context, request *CreateUserSigRequest) (response *CreateUserSigResponse, err error) {
    if request == nil {
        request = NewCreateUserSigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "CreateUserSig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateUserSig require credential")
    }

    request.SetContext(ctx)
    
    response = NewCreateUserSigResponse()
    err = c.Send(request, response)
    return
}

func NewDeleteCCCSkillGroupRequest() (request *DeleteCCCSkillGroupRequest) {
    request = &DeleteCCCSkillGroupRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DeleteCCCSkillGroup")
    
    
    return
}

func NewDeleteCCCSkillGroupResponse() (response *DeleteCCCSkillGroupResponse) {
    response = &DeleteCCCSkillGroupResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteCCCSkillGroup
// This API is used to delete a skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DeleteCCCSkillGroup(request *DeleteCCCSkillGroupRequest) (response *DeleteCCCSkillGroupResponse, err error) {
    return c.DeleteCCCSkillGroupWithContext(context.Background(), request)
}

// DeleteCCCSkillGroup
// This API is used to delete a skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DeleteCCCSkillGroupWithContext(ctx context.Context, request *DeleteCCCSkillGroupRequest) (response *DeleteCCCSkillGroupResponse, err error) {
    if request == nil {
        request = NewDeleteCCCSkillGroupRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DeleteCCCSkillGroup")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteCCCSkillGroup require credential")
    }

    request.SetContext(ctx)
    
    response = NewDeleteCCCSkillGroupResponse()
    err = c.Send(request, response)
    return
}

func NewDeleteExtensionRequest() (request *DeleteExtensionRequest) {
    request = &DeleteExtensionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DeleteExtension")
    
    
    return
}

func NewDeleteExtensionResponse() (response *DeleteExtensionResponse) {
    response = &DeleteExtensionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteExtension
// This API is used to delete telephone accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DeleteExtension(request *DeleteExtensionRequest) (response *DeleteExtensionResponse, err error) {
    return c.DeleteExtensionWithContext(context.Background(), request)
}

// DeleteExtension
// This API is used to delete telephone accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DeleteExtensionWithContext(ctx context.Context, request *DeleteExtensionRequest) (response *DeleteExtensionResponse, err error) {
    if request == nil {
        request = NewDeleteExtensionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DeleteExtension")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteExtension require credential")
    }

    request.SetContext(ctx)
    
    response = NewDeleteExtensionResponse()
    err = c.Send(request, response)
    return
}

func NewDeletePredictiveDialingCampaignRequest() (request *DeletePredictiveDialingCampaignRequest) {
    request = &DeletePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DeletePredictiveDialingCampaign")
    
    
    return
}

func NewDeletePredictiveDialingCampaignResponse() (response *DeletePredictiveDialingCampaignResponse) {
    response = &DeletePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeletePredictiveDialingCampaign
// This API is used to delete the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DeletePredictiveDialingCampaign(request *DeletePredictiveDialingCampaignRequest) (response *DeletePredictiveDialingCampaignResponse, err error) {
    return c.DeletePredictiveDialingCampaignWithContext(context.Background(), request)
}

// DeletePredictiveDialingCampaign
// This API is used to delete the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DeletePredictiveDialingCampaignWithContext(ctx context.Context, request *DeletePredictiveDialingCampaignRequest) (response *DeletePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewDeletePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DeletePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeletePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewDeletePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewDeleteStaffRequest() (request *DeleteStaffRequest) {
    request = &DeleteStaffRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DeleteStaff")
    
    
    return
}

func NewDeleteStaffResponse() (response *DeleteStaffResponse) {
    response = &DeleteStaffResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteStaff
// This API is used to delete the agent information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DeleteStaff(request *DeleteStaffRequest) (response *DeleteStaffResponse, err error) {
    return c.DeleteStaffWithContext(context.Background(), request)
}

// DeleteStaff
// This API is used to delete the agent information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DeleteStaffWithContext(ctx context.Context, request *DeleteStaffRequest) (response *DeleteStaffResponse, err error) {
    if request == nil {
        request = NewDeleteStaffRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DeleteStaff")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteStaff require credential")
    }

    request.SetContext(ctx)
    
    response = NewDeleteStaffResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAIAgentInfoListRequest() (request *DescribeAIAgentInfoListRequest) {
    request = &DescribeAIAgentInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAIAgentInfoList")
    
    
    return
}

func NewDescribeAIAgentInfoListResponse() (response *DescribeAIAgentInfoListResponse) {
    response = &DescribeAIAgentInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAIAgentInfoList
// This API is used to query the information list of configured Intelligent Agents under a specified instance (SdkAppId) by paging, including basic information such as Intelligent Agent ID and name.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAIAgentInfoList(request *DescribeAIAgentInfoListRequest) (response *DescribeAIAgentInfoListResponse, err error) {
    return c.DescribeAIAgentInfoListWithContext(context.Background(), request)
}

// DescribeAIAgentInfoList
// This API is used to query the information list of configured Intelligent Agents under a specified instance (SdkAppId) by paging, including basic information such as Intelligent Agent ID and name.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAIAgentInfoListWithContext(ctx context.Context, request *DescribeAIAgentInfoListRequest) (response *DescribeAIAgentInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeAIAgentInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAIAgentInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAIAgentInfoList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAIAgentInfoListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAIAnalysisResultRequest() (request *DescribeAIAnalysisResultRequest) {
    request = &DescribeAIAnalysisResultRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAIAnalysisResult")
    
    
    return
}

func NewDescribeAIAnalysisResultResponse() (response *DescribeAIAnalysisResultResponse) {
    response = &DescribeAIAnalysisResultResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAIAnalysisResult
// This API is used to obtain AI Conversation Analytics results.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAIAnalysisResult(request *DescribeAIAnalysisResultRequest) (response *DescribeAIAnalysisResultResponse, err error) {
    return c.DescribeAIAnalysisResultWithContext(context.Background(), request)
}

// DescribeAIAnalysisResult
// This API is used to obtain AI Conversation Analytics results.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAIAnalysisResultWithContext(ctx context.Context, request *DescribeAIAnalysisResultRequest) (response *DescribeAIAnalysisResultResponse, err error) {
    if request == nil {
        request = NewDescribeAIAnalysisResultRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAIAnalysisResult")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAIAnalysisResult require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAIAnalysisResultResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAICallExtractResultRequest() (request *DescribeAICallExtractResultRequest) {
    request = &DescribeAICallExtractResultRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAICallExtractResult")
    
    
    return
}

func NewDescribeAICallExtractResultResponse() (response *DescribeAICallExtractResultResponse) {
    response = &DescribeAICallExtractResultResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAICallExtractResult
// This API is used to query specified session's post-call Tag results by Session ID after the Intelligent Agent call session ends. Related post-call Tags need to be configured in advance in the management console. For details, please refer to post-call Tags (https://www.tencentcloud.com/document/product/679/119800?from_cn_redirect=1).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAICallExtractResult(request *DescribeAICallExtractResultRequest) (response *DescribeAICallExtractResultResponse, err error) {
    return c.DescribeAICallExtractResultWithContext(context.Background(), request)
}

// DescribeAICallExtractResult
// This API is used to query specified session's post-call Tag results by Session ID after the Intelligent Agent call session ends. Related post-call Tags need to be configured in advance in the management console. For details, please refer to post-call Tags (https://www.tencentcloud.com/document/product/679/119800?from_cn_redirect=1).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAICallExtractResultWithContext(ctx context.Context, request *DescribeAICallExtractResultRequest) (response *DescribeAICallExtractResultResponse, err error) {
    if request == nil {
        request = NewDescribeAICallExtractResultRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAICallExtractResult")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAICallExtractResult require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAICallExtractResultResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAILatencyRequest() (request *DescribeAILatencyRequest) {
    request = &DescribeAILatencyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAILatency")
    
    
    return
}

func NewDescribeAILatencyResponse() (response *DescribeAILatencyResponse) {
    response = &DescribeAILatencyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAILatency
// Call this API to query the processing latency detail and stats of specified Session by Session ID within a specific time period. The latency info includes:.
//
// -End-to-end (ETE) delay: Statistics of the overall duration from user voice input to AI returning a complete response.
//
// -ASR latency: statistics of the processing time consumption required for voice input to be recognized as text.
//
// -LLM latency: Statistics of inference latency for AI model to generate text content.
//
// -Text To Speech (TTS) latency: Statistics of text conversion to speech audio synthesis duration.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAILatency(request *DescribeAILatencyRequest) (response *DescribeAILatencyResponse, err error) {
    return c.DescribeAILatencyWithContext(context.Background(), request)
}

// DescribeAILatency
// Call this API to query the processing latency detail and stats of specified Session by Session ID within a specific time period. The latency info includes:.
//
// -End-to-end (ETE) delay: Statistics of the overall duration from user voice input to AI returning a complete response.
//
// -ASR latency: statistics of the processing time consumption required for voice input to be recognized as text.
//
// -LLM latency: Statistics of inference latency for AI model to generate text content.
//
// -Text To Speech (TTS) latency: Statistics of text conversion to speech audio synthesis duration.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeAILatencyWithContext(ctx context.Context, request *DescribeAILatencyRequest) (response *DescribeAILatencyResponse, err error) {
    if request == nil {
        request = NewDescribeAILatencyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAILatency")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAILatency require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAILatencyResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAgentCruiseDialingCampaignRequest() (request *DescribeAgentCruiseDialingCampaignRequest) {
    request = &DescribeAgentCruiseDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAgentCruiseDialingCampaign")
    
    
    return
}

func NewDescribeAgentCruiseDialingCampaignResponse() (response *DescribeAgentCruiseDialingCampaignResponse) {
    response = &DescribeAgentCruiseDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAgentCruiseDialingCampaign
// Query Agent Cruise-style Outbound Call Task
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAgentCruiseDialingCampaign(request *DescribeAgentCruiseDialingCampaignRequest) (response *DescribeAgentCruiseDialingCampaignResponse, err error) {
    return c.DescribeAgentCruiseDialingCampaignWithContext(context.Background(), request)
}

// DescribeAgentCruiseDialingCampaign
// Query Agent Cruise-style Outbound Call Task
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAgentCruiseDialingCampaignWithContext(ctx context.Context, request *DescribeAgentCruiseDialingCampaignRequest) (response *DescribeAgentCruiseDialingCampaignResponse, err error) {
    if request == nil {
        request = NewDescribeAgentCruiseDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAgentCruiseDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAgentCruiseDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAgentCruiseDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAutoCalloutTaskRequest() (request *DescribeAutoCalloutTaskRequest) {
    request = &DescribeAutoCalloutTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAutoCalloutTask")
    
    
    return
}

func NewDescribeAutoCalloutTaskResponse() (response *DescribeAutoCalloutTaskResponse) {
    response = &DescribeAutoCalloutTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAutoCalloutTask
// This API is used to query detailed information of an automatic outbound call task by TaskId, including basic configuration, start and end time, name list, execution status, and call status.
//
// This API is usually used together with Create Bulk Automatic Outbound Call Task (https://www.tencentcloud.com/document/product/679/69194?from_cn_redirect=1) to check whether the task configuration takes effect, the current task status, and real-time progress during execution once created.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAutoCalloutTask(request *DescribeAutoCalloutTaskRequest) (response *DescribeAutoCalloutTaskResponse, err error) {
    return c.DescribeAutoCalloutTaskWithContext(context.Background(), request)
}

// DescribeAutoCalloutTask
// This API is used to query detailed information of an automatic outbound call task by TaskId, including basic configuration, start and end time, name list, execution status, and call status.
//
// This API is usually used together with Create Bulk Automatic Outbound Call Task (https://www.tencentcloud.com/document/product/679/69194?from_cn_redirect=1) to check whether the task configuration takes effect, the current task status, and real-time progress during execution once created.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAutoCalloutTaskWithContext(ctx context.Context, request *DescribeAutoCalloutTaskRequest) (response *DescribeAutoCalloutTaskResponse, err error) {
    if request == nil {
        request = NewDescribeAutoCalloutTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAutoCalloutTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAutoCalloutTask require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAutoCalloutTaskResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeAutoCalloutTasksRequest() (request *DescribeAutoCalloutTasksRequest) {
    request = &DescribeAutoCalloutTasksRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeAutoCalloutTasks")
    
    
    return
}

func NewDescribeAutoCalloutTasksResponse() (response *DescribeAutoCalloutTasksResponse) {
    response = &DescribeAutoCalloutTasksResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAutoCalloutTasks
// Batch Query Automatic Outbound Call Tasks
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAutoCalloutTasks(request *DescribeAutoCalloutTasksRequest) (response *DescribeAutoCalloutTasksResponse, err error) {
    return c.DescribeAutoCalloutTasksWithContext(context.Background(), request)
}

// DescribeAutoCalloutTasks
// Batch Query Automatic Outbound Call Tasks
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAutoCalloutTasksWithContext(ctx context.Context, request *DescribeAutoCalloutTasksRequest) (response *DescribeAutoCalloutTasksResponse, err error) {
    if request == nil {
        request = NewDescribeAutoCalloutTasksRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeAutoCalloutTasks")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAutoCalloutTasks require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeAutoCalloutTasksResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeCCCBuyInfoListRequest() (request *DescribeCCCBuyInfoListRequest) {
    request = &DescribeCCCBuyInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeCCCBuyInfoList")
    
    
    return
}

func NewDescribeCCCBuyInfoListResponse() (response *DescribeCCCBuyInfoListResponse) {
    response = &DescribeCCCBuyInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeCCCBuyInfoList
// This API is used to access the user purchasing information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeCCCBuyInfoList(request *DescribeCCCBuyInfoListRequest) (response *DescribeCCCBuyInfoListResponse, err error) {
    return c.DescribeCCCBuyInfoListWithContext(context.Background(), request)
}

// DescribeCCCBuyInfoList
// This API is used to access the user purchasing information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeCCCBuyInfoListWithContext(ctx context.Context, request *DescribeCCCBuyInfoListRequest) (response *DescribeCCCBuyInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeCCCBuyInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeCCCBuyInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeCCCBuyInfoList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeCCCBuyInfoListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeCallInMetricsRequest() (request *DescribeCallInMetricsRequest) {
    request = &DescribeCallInMetricsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeCallInMetrics")
    
    
    return
}

func NewDescribeCallInMetricsResponse() (response *DescribeCallInMetricsResponse) {
    response = &DescribeCallInMetricsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeCallInMetrics
// This API is used to access the inbound real-time data statistical metrics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeCallInMetrics(request *DescribeCallInMetricsRequest) (response *DescribeCallInMetricsResponse, err error) {
    return c.DescribeCallInMetricsWithContext(context.Background(), request)
}

// DescribeCallInMetrics
// This API is used to access the inbound real-time data statistical metrics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeCallInMetricsWithContext(ctx context.Context, request *DescribeCallInMetricsRequest) (response *DescribeCallInMetricsResponse, err error) {
    if request == nil {
        request = NewDescribeCallInMetricsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeCallInMetrics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeCallInMetrics require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeCallInMetricsResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeExtensionRequest() (request *DescribeExtensionRequest) {
    request = &DescribeExtensionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeExtension")
    
    
    return
}

func NewDescribeExtensionResponse() (response *DescribeExtensionResponse) {
    response = &DescribeExtensionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeExtension
// This API is used to access the telephone information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) DescribeExtension(request *DescribeExtensionRequest) (response *DescribeExtensionResponse, err error) {
    return c.DescribeExtensionWithContext(context.Background(), request)
}

// DescribeExtension
// This API is used to access the telephone information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) DescribeExtensionWithContext(ctx context.Context, request *DescribeExtensionRequest) (response *DescribeExtensionResponse, err error) {
    if request == nil {
        request = NewDescribeExtensionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeExtension")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeExtension require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeExtensionResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeExtensionsRequest() (request *DescribeExtensionsRequest) {
    request = &DescribeExtensionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeExtensions")
    
    
    return
}

func NewDescribeExtensionsResponse() (response *DescribeExtensionsResponse) {
    response = &DescribeExtensionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeExtensions
// This API is used to query the telephone list information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeExtensions(request *DescribeExtensionsRequest) (response *DescribeExtensionsResponse, err error) {
    return c.DescribeExtensionsWithContext(context.Background(), request)
}

// DescribeExtensions
// This API is used to query the telephone list information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeExtensionsWithContext(ctx context.Context, request *DescribeExtensionsRequest) (response *DescribeExtensionsResponse, err error) {
    if request == nil {
        request = NewDescribeExtensionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeExtensions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeExtensions require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeExtensionsResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeIvrAudioListRequest() (request *DescribeIvrAudioListRequest) {
    request = &DescribeIvrAudioListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeIvrAudioList")
    
    
    return
}

func NewDescribeIvrAudioListResponse() (response *DescribeIvrAudioListResponse) {
    response = &DescribeIvrAudioListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeIvrAudioList
// Query IVR Audio File List Information
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeIvrAudioList(request *DescribeIvrAudioListRequest) (response *DescribeIvrAudioListResponse, err error) {
    return c.DescribeIvrAudioListWithContext(context.Background(), request)
}

// DescribeIvrAudioList
// Query IVR Audio File List Information
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeIvrAudioListWithContext(ctx context.Context, request *DescribeIvrAudioListRequest) (response *DescribeIvrAudioListResponse, err error) {
    if request == nil {
        request = NewDescribeIvrAudioListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeIvrAudioList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeIvrAudioList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeIvrAudioListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeNumbersRequest() (request *DescribeNumbersRequest) {
    request = &DescribeNumbersRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeNumbers")
    
    
    return
}

func NewDescribeNumbersResponse() (response *DescribeNumbersResponse) {
    response = &DescribeNumbersResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeNumbers
// This API is used to query the number list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeNumbers(request *DescribeNumbersRequest) (response *DescribeNumbersResponse, err error) {
    return c.DescribeNumbersWithContext(context.Background(), request)
}

// DescribeNumbers
// This API is used to query the number list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeNumbersWithContext(ctx context.Context, request *DescribeNumbersRequest) (response *DescribeNumbersResponse, err error) {
    if request == nil {
        request = NewDescribeNumbersRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeNumbers")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeNumbers require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeNumbersResponse()
    err = c.Send(request, response)
    return
}

func NewDescribePSTNActiveSessionListRequest() (request *DescribePSTNActiveSessionListRequest) {
    request = &DescribePSTNActiveSessionListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribePSTNActiveSessionList")
    
    
    return
}

func NewDescribePSTNActiveSessionListResponse() (response *DescribePSTNActiveSessionListResponse) {
    response = &DescribePSTNActiveSessionListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePSTNActiveSessionList
// This API is used to access the current calling session list.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) DescribePSTNActiveSessionList(request *DescribePSTNActiveSessionListRequest) (response *DescribePSTNActiveSessionListResponse, err error) {
    return c.DescribePSTNActiveSessionListWithContext(context.Background(), request)
}

// DescribePSTNActiveSessionList
// This API is used to access the current calling session list.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  LIMITEXCEEDED_OUTOFCOUNTLIMIT = "LimitExceeded.OutOfCountLimit"
func (c *Client) DescribePSTNActiveSessionListWithContext(ctx context.Context, request *DescribePSTNActiveSessionListRequest) (response *DescribePSTNActiveSessionListResponse, err error) {
    if request == nil {
        request = NewDescribePSTNActiveSessionListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribePSTNActiveSessionList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePSTNActiveSessionList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribePSTNActiveSessionListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribePredictiveDialingCampaignRequest() (request *DescribePredictiveDialingCampaignRequest) {
    request = &DescribePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribePredictiveDialingCampaign")
    
    
    return
}

func NewDescribePredictiveDialingCampaignResponse() (response *DescribePredictiveDialingCampaignResponse) {
    response = &DescribePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePredictiveDialingCampaign
// This API is used to query the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingCampaign(request *DescribePredictiveDialingCampaignRequest) (response *DescribePredictiveDialingCampaignResponse, err error) {
    return c.DescribePredictiveDialingCampaignWithContext(context.Background(), request)
}

// DescribePredictiveDialingCampaign
// This API is used to query the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingCampaignWithContext(ctx context.Context, request *DescribePredictiveDialingCampaignRequest) (response *DescribePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewDescribePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewDescribePredictiveDialingCampaignsRequest() (request *DescribePredictiveDialingCampaignsRequest) {
    request = &DescribePredictiveDialingCampaignsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribePredictiveDialingCampaigns")
    
    
    return
}

func NewDescribePredictiveDialingCampaignsResponse() (response *DescribePredictiveDialingCampaignsResponse) {
    response = &DescribePredictiveDialingCampaignsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePredictiveDialingCampaigns
// This API is used to query the predictive outbound call task list.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingCampaigns(request *DescribePredictiveDialingCampaignsRequest) (response *DescribePredictiveDialingCampaignsResponse, err error) {
    return c.DescribePredictiveDialingCampaignsWithContext(context.Background(), request)
}

// DescribePredictiveDialingCampaigns
// This API is used to query the predictive outbound call task list.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingCampaignsWithContext(ctx context.Context, request *DescribePredictiveDialingCampaignsRequest) (response *DescribePredictiveDialingCampaignsResponse, err error) {
    if request == nil {
        request = NewDescribePredictiveDialingCampaignsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribePredictiveDialingCampaigns")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePredictiveDialingCampaigns require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribePredictiveDialingCampaignsResponse()
    err = c.Send(request, response)
    return
}

func NewDescribePredictiveDialingSessionsRequest() (request *DescribePredictiveDialingSessionsRequest) {
    request = &DescribePredictiveDialingSessionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribePredictiveDialingSessions")
    
    
    return
}

func NewDescribePredictiveDialingSessionsResponse() (response *DescribePredictiveDialingSessionsResponse) {
    response = &DescribePredictiveDialingSessionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePredictiveDialingSessions
// This API is used to query the predictive outbound call list.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingSessions(request *DescribePredictiveDialingSessionsRequest) (response *DescribePredictiveDialingSessionsResponse, err error) {
    return c.DescribePredictiveDialingSessionsWithContext(context.Background(), request)
}

// DescribePredictiveDialingSessions
// This API is used to query the predictive outbound call list.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribePredictiveDialingSessionsWithContext(ctx context.Context, request *DescribePredictiveDialingSessionsRequest) (response *DescribePredictiveDialingSessionsResponse, err error) {
    if request == nil {
        request = NewDescribePredictiveDialingSessionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribePredictiveDialingSessions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePredictiveDialingSessions require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribePredictiveDialingSessionsResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeProtectedTelCdrRequest() (request *DescribeProtectedTelCdrRequest) {
    request = &DescribeProtectedTelCdrRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeProtectedTelCdr")
    
    
    return
}

func NewDescribeProtectedTelCdrResponse() (response *DescribeProtectedTelCdrResponse) {
    response = &DescribeProtectedTelCdrResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeProtectedTelCdr
// This API is used to access protected phone service records and recordings for both inbound and outbound calls.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeProtectedTelCdr(request *DescribeProtectedTelCdrRequest) (response *DescribeProtectedTelCdrResponse, err error) {
    return c.DescribeProtectedTelCdrWithContext(context.Background(), request)
}

// DescribeProtectedTelCdr
// This API is used to access protected phone service records and recordings for both inbound and outbound calls.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeProtectedTelCdrWithContext(ctx context.Context, request *DescribeProtectedTelCdrRequest) (response *DescribeProtectedTelCdrResponse, err error) {
    if request == nil {
        request = NewDescribeProtectedTelCdrRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeProtectedTelCdr")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeProtectedTelCdr require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeProtectedTelCdrResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeSessionDetailRequest() (request *DescribeSessionDetailRequest) {
    request = &DescribeSessionDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeSessionDetail")
    
    
    return
}

func NewDescribeSessionDetailResponse() (response *DescribeSessionDetailResponse) {
    response = &DescribeSessionDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSessionDetail
// This API is used to query call details for a single call by session id and timestamp after call ends, including caller and contact information, voice recording.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeSessionDetail(request *DescribeSessionDetailRequest) (response *DescribeSessionDetailResponse, err error) {
    return c.DescribeSessionDetailWithContext(context.Background(), request)
}

// DescribeSessionDetail
// This API is used to query call details for a single call by session id and timestamp after call ends, including caller and contact information, voice recording.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeSessionDetailWithContext(ctx context.Context, request *DescribeSessionDetailRequest) (response *DescribeSessionDetailResponse, err error) {
    if request == nil {
        request = NewDescribeSessionDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeSessionDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSessionDetail require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeSessionDetailResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeSkillGroupInfoListRequest() (request *DescribeSkillGroupInfoListRequest) {
    request = &DescribeSkillGroupInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeSkillGroupInfoList")
    
    
    return
}

func NewDescribeSkillGroupInfoListResponse() (response *DescribeSkillGroupInfoListResponse) {
    response = &DescribeSkillGroupInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSkillGroupInfoList
// This API is used to access the skill group information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeSkillGroupInfoList(request *DescribeSkillGroupInfoListRequest) (response *DescribeSkillGroupInfoListResponse, err error) {
    return c.DescribeSkillGroupInfoListWithContext(context.Background(), request)
}

// DescribeSkillGroupInfoList
// This API is used to access the skill group information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeSkillGroupInfoListWithContext(ctx context.Context, request *DescribeSkillGroupInfoListRequest) (response *DescribeSkillGroupInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeSkillGroupInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeSkillGroupInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSkillGroupInfoList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeSkillGroupInfoListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeStaffInfoListRequest() (request *DescribeStaffInfoListRequest) {
    request = &DescribeStaffInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeStaffInfoList")
    
    
    return
}

func NewDescribeStaffInfoListResponse() (response *DescribeStaffInfoListResponse) {
    response = &DescribeStaffInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeStaffInfoList
// This API is used to access the agent information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeStaffInfoList(request *DescribeStaffInfoListRequest) (response *DescribeStaffInfoListResponse, err error) {
    return c.DescribeStaffInfoListWithContext(context.Background(), request)
}

// DescribeStaffInfoList
// This API is used to access the agent information list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeStaffInfoListWithContext(ctx context.Context, request *DescribeStaffInfoListRequest) (response *DescribeStaffInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeStaffInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeStaffInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeStaffInfoList require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeStaffInfoListResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeStaffStatusHistoryRequest() (request *DescribeStaffStatusHistoryRequest) {
    request = &DescribeStaffStatusHistoryRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeStaffStatusHistory")
    
    
    return
}

func NewDescribeStaffStatusHistoryResponse() (response *DescribeStaffStatusHistoryResponse) {
    response = &DescribeStaffStatusHistoryResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeStaffStatusHistory
// This API is used to query agent status history.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeStaffStatusHistory(request *DescribeStaffStatusHistoryRequest) (response *DescribeStaffStatusHistoryResponse, err error) {
    return c.DescribeStaffStatusHistoryWithContext(context.Background(), request)
}

// DescribeStaffStatusHistory
// This API is used to query agent status history.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeStaffStatusHistoryWithContext(ctx context.Context, request *DescribeStaffStatusHistoryRequest) (response *DescribeStaffStatusHistoryResponse, err error) {
    if request == nil {
        request = NewDescribeStaffStatusHistoryRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeStaffStatusHistory")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeStaffStatusHistory require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeStaffStatusHistoryResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeStaffStatusMetricsRequest() (request *DescribeStaffStatusMetricsRequest) {
    request = &DescribeStaffStatusMetricsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeStaffStatusMetrics")
    
    
    return
}

func NewDescribeStaffStatusMetricsResponse() (response *DescribeStaffStatusMetricsResponse) {
    response = &DescribeStaffStatusMetricsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeStaffStatusMetrics
// This API is used to access the real-time status statistics metrics of the agent.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeStaffStatusMetrics(request *DescribeStaffStatusMetricsRequest) (response *DescribeStaffStatusMetricsResponse, err error) {
    return c.DescribeStaffStatusMetricsWithContext(context.Background(), request)
}

// DescribeStaffStatusMetrics
// This API is used to access the real-time status statistics metrics of the agent.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeStaffStatusMetricsWithContext(ctx context.Context, request *DescribeStaffStatusMetricsRequest) (response *DescribeStaffStatusMetricsResponse, err error) {
    if request == nil {
        request = NewDescribeStaffStatusMetricsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeStaffStatusMetrics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeStaffStatusMetrics require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeStaffStatusMetricsResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeTelCallInfoRequest() (request *DescribeTelCallInfoRequest) {
    request = &DescribeTelCallInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeTelCallInfo")
    
    
    return
}

func NewDescribeTelCallInfoResponse() (response *DescribeTelCallInfoResponse) {
    response = &DescribeTelCallInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTelCallInfo
// This API is used to access telephone consumption statistics by instance.
//
// error code that may be returned:
//  FAILEDOPERATION_DUPLICATEDACCOUNT = "FailedOperation.DuplicatedAccount"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelCallInfo(request *DescribeTelCallInfoRequest) (response *DescribeTelCallInfoResponse, err error) {
    return c.DescribeTelCallInfoWithContext(context.Background(), request)
}

// DescribeTelCallInfo
// This API is used to access telephone consumption statistics by instance.
//
// error code that may be returned:
//  FAILEDOPERATION_DUPLICATEDACCOUNT = "FailedOperation.DuplicatedAccount"
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelCallInfoWithContext(ctx context.Context, request *DescribeTelCallInfoRequest) (response *DescribeTelCallInfoResponse, err error) {
    if request == nil {
        request = NewDescribeTelCallInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeTelCallInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTelCallInfo require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeTelCallInfoResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeTelCdrRequest() (request *DescribeTelCdrRequest) {
    request = &DescribeTelCdrRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeTelCdr")
    
    
    return
}

func NewDescribeTelCdrResponse() (response *DescribeTelCdrResponse) {
    response = &DescribeTelCdrResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTelCdr
// This API is used to access phone service records and recordings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelCdr(request *DescribeTelCdrRequest) (response *DescribeTelCdrResponse, err error) {
    return c.DescribeTelCdrWithContext(context.Background(), request)
}

// DescribeTelCdr
// This API is used to access phone service records and recordings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelCdrWithContext(ctx context.Context, request *DescribeTelCdrRequest) (response *DescribeTelCdrResponse, err error) {
    if request == nil {
        request = NewDescribeTelCdrRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeTelCdr")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTelCdr require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeTelCdrResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeTelRecordAsrRequest() (request *DescribeTelRecordAsrRequest) {
    request = &DescribeTelRecordAsrRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeTelRecordAsr")
    
    
    return
}

func NewDescribeTelRecordAsrResponse() (response *DescribeTelRecordAsrResponse) {
    response = &DescribeTelRecordAsrResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTelRecordAsr
// Pull conversation recording for text information
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTelRecordAsr(request *DescribeTelRecordAsrRequest) (response *DescribeTelRecordAsrResponse, err error) {
    return c.DescribeTelRecordAsrWithContext(context.Background(), request)
}

// DescribeTelRecordAsr
// Pull conversation recording for text information
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTelRecordAsrWithContext(ctx context.Context, request *DescribeTelRecordAsrRequest) (response *DescribeTelRecordAsrResponse, err error) {
    if request == nil {
        request = NewDescribeTelRecordAsrRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeTelRecordAsr")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTelRecordAsr require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeTelRecordAsrResponse()
    err = c.Send(request, response)
    return
}

func NewDescribeTelSessionRequest() (request *DescribeTelSessionRequest) {
    request = &DescribeTelSessionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DescribeTelSession")
    
    
    return
}

func NewDescribeTelSessionResponse() (response *DescribeTelSessionResponse) {
    response = &DescribeTelSessionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTelSession
// This API is used to access the PSTN session information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelSession(request *DescribeTelSessionRequest) (response *DescribeTelSessionResponse, err error) {
    return c.DescribeTelSessionWithContext(context.Background(), request)
}

// DescribeTelSession
// This API is used to access the PSTN session information.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) DescribeTelSessionWithContext(ctx context.Context, request *DescribeTelSessionRequest) (response *DescribeTelSessionResponse, err error) {
    if request == nil {
        request = NewDescribeTelSessionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DescribeTelSession")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTelSession require credential")
    }

    request.SetContext(ctx)
    
    response = NewDescribeTelSessionResponse()
    err = c.Send(request, response)
    return
}

func NewDisableCCCPhoneNumberRequest() (request *DisableCCCPhoneNumberRequest) {
    request = &DisableCCCPhoneNumberRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "DisableCCCPhoneNumber")
    
    
    return
}

func NewDisableCCCPhoneNumberResponse() (response *DisableCCCPhoneNumberResponse) {
    response = &DisableCCCPhoneNumberResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DisableCCCPhoneNumber
// This API is used to disable numbers.
//
// error code that may be returned:
//  FAILEDOPERATION_CURSTATENOTALLOWMODIFY = "FailedOperation.CurStateNotAllowModify"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_DUPLICATEADDRESS = "InvalidParameter.DuplicateAddress"
//  INVALIDPARAMETER_DUPLICATEPHONENUMBER = "InvalidParameter.DuplicatePhoneNumber"
//  INVALIDPARAMETER_DUPLICATESIPACCOUNT = "InvalidParameter.DuplicateSipAccount"
//  INVALIDPARAMETER_ILLEGALADDRESS = "InvalidParameter.IllegalAddress"
//  INVALIDPARAMETER_ILLEGALPHONENUMBER = "InvalidParameter.IllegalPhoneNumber"
//  INVALIDPARAMETER_INVALIDADDRESS = "InvalidParameter.InvalidAddress"
//  INVALIDPARAMETER_INVALIDIP = "InvalidParameter.InvalidIP"
//  INVALIDPARAMETER_INVALIDPHONENUMBER = "InvalidParameter.InvalidPhoneNumber"
//  INVALIDPARAMETER_INVALIDPORT = "InvalidParameter.InvalidPort"
//  INVALIDPARAMETER_SIPACCOUNTPASSWORDFORMAT = "InvalidParameter.SipAccountPasswordFormat"
//  INVALIDPARAMETER_SIPACCOUNTUSERFORMAT = "InvalidParameter.SipAccountUserFormat"
//  INVALIDPARAMETER_SIPTRUNKINUSED = "InvalidParameter.SipTrunkInUsed"
//  INVALIDPARAMETER_SIPTRUNKNOTFOUND = "InvalidParameter.SipTrunkNotFound"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DisableCCCPhoneNumber(request *DisableCCCPhoneNumberRequest) (response *DisableCCCPhoneNumberResponse, err error) {
    return c.DisableCCCPhoneNumberWithContext(context.Background(), request)
}

// DisableCCCPhoneNumber
// This API is used to disable numbers.
//
// error code that may be returned:
//  FAILEDOPERATION_CURSTATENOTALLOWMODIFY = "FailedOperation.CurStateNotAllowModify"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER_DUPLICATEADDRESS = "InvalidParameter.DuplicateAddress"
//  INVALIDPARAMETER_DUPLICATEPHONENUMBER = "InvalidParameter.DuplicatePhoneNumber"
//  INVALIDPARAMETER_DUPLICATESIPACCOUNT = "InvalidParameter.DuplicateSipAccount"
//  INVALIDPARAMETER_ILLEGALADDRESS = "InvalidParameter.IllegalAddress"
//  INVALIDPARAMETER_ILLEGALPHONENUMBER = "InvalidParameter.IllegalPhoneNumber"
//  INVALIDPARAMETER_INVALIDADDRESS = "InvalidParameter.InvalidAddress"
//  INVALIDPARAMETER_INVALIDIP = "InvalidParameter.InvalidIP"
//  INVALIDPARAMETER_INVALIDPHONENUMBER = "InvalidParameter.InvalidPhoneNumber"
//  INVALIDPARAMETER_INVALIDPORT = "InvalidParameter.InvalidPort"
//  INVALIDPARAMETER_SIPACCOUNTPASSWORDFORMAT = "InvalidParameter.SipAccountPasswordFormat"
//  INVALIDPARAMETER_SIPACCOUNTUSERFORMAT = "InvalidParameter.SipAccountUserFormat"
//  INVALIDPARAMETER_SIPTRUNKINUSED = "InvalidParameter.SipTrunkInUsed"
//  INVALIDPARAMETER_SIPTRUNKNOTFOUND = "InvalidParameter.SipTrunkNotFound"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DisableCCCPhoneNumberWithContext(ctx context.Context, request *DisableCCCPhoneNumberRequest) (response *DisableCCCPhoneNumberResponse, err error) {
    if request == nil {
        request = NewDisableCCCPhoneNumberRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "DisableCCCPhoneNumber")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DisableCCCPhoneNumber require credential")
    }

    request.SetContext(ctx)
    
    response = NewDisableCCCPhoneNumberResponse()
    err = c.Send(request, response)
    return
}

func NewForceMemberOfflineRequest() (request *ForceMemberOfflineRequest) {
    request = &ForceMemberOfflineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ForceMemberOffline")
    
    
    return
}

func NewForceMemberOfflineResponse() (response *ForceMemberOfflineResponse) {
    response = &ForceMemberOfflineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ForceMemberOffline
// This API is used to force customer service to go offline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ForceMemberOffline(request *ForceMemberOfflineRequest) (response *ForceMemberOfflineResponse, err error) {
    return c.ForceMemberOfflineWithContext(context.Background(), request)
}

// ForceMemberOffline
// This API is used to force customer service to go offline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ForceMemberOfflineWithContext(ctx context.Context, request *ForceMemberOfflineRequest) (response *ForceMemberOfflineResponse, err error) {
    if request == nil {
        request = NewForceMemberOfflineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ForceMemberOffline")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ForceMemberOffline require credential")
    }

    request.SetContext(ctx)
    
    response = NewForceMemberOfflineResponse()
    err = c.Send(request, response)
    return
}

func NewHangUpCallRequest() (request *HangUpCallRequest) {
    request = &HangUpCallRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "HangUpCall")
    
    
    return
}

func NewHangUpCallResponse() (response *HangUpCallResponse) {
    response = &HangUpCallResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// HangUpCall
// This API is used to hang up the phone.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) HangUpCall(request *HangUpCallRequest) (response *HangUpCallResponse, err error) {
    return c.HangUpCallWithContext(context.Background(), request)
}

// HangUpCall
// This API is used to hang up the phone.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
func (c *Client) HangUpCallWithContext(ctx context.Context, request *HangUpCallRequest) (response *HangUpCallResponse, err error) {
    if request == nil {
        request = NewHangUpCallRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "HangUpCall")
    
    if c.GetCredential() == nil {
        return nil, errors.New("HangUpCall require credential")
    }

    request.SetContext(ctx)
    
    response = NewHangUpCallResponse()
    err = c.Send(request, response)
    return
}

func NewModifyExtensionRequest() (request *ModifyExtensionRequest) {
    request = &ModifyExtensionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ModifyExtension")
    
    
    return
}

func NewModifyExtensionResponse() (response *ModifyExtensionResponse) {
    response = &ModifyExtensionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyExtension
// This API is used to modify telephone accounts (binding skill group, binding agent account).
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ModifyExtension(request *ModifyExtensionRequest) (response *ModifyExtensionResponse, err error) {
    return c.ModifyExtensionWithContext(context.Background(), request)
}

// ModifyExtension
// This API is used to modify telephone accounts (binding skill group, binding agent account).
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ModifyExtensionWithContext(ctx context.Context, request *ModifyExtensionRequest) (response *ModifyExtensionResponse, err error) {
    if request == nil {
        request = NewModifyExtensionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ModifyExtension")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyExtension require credential")
    }

    request.SetContext(ctx)
    
    response = NewModifyExtensionResponse()
    err = c.Send(request, response)
    return
}

func NewModifyOwnNumberApplyRequest() (request *ModifyOwnNumberApplyRequest) {
    request = &ModifyOwnNumberApplyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ModifyOwnNumberApply")
    
    
    return
}

func NewModifyOwnNumberApplyResponse() (response *ModifyOwnNumberApplyResponse) {
    response = &ModifyOwnNumberApplyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyOwnNumberApply
// Modify customer's own number approval form
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_APPLYIDNOTEXIST = "InvalidParameterValue.ApplyIDNotExist"
//  INVALIDPARAMETERVALUE_ERRORAPPLYSTATUS = "InvalidParameterValue.ErrorApplyStatus"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMINVALID = "InvalidParameterValue.PhoneNumInvalid"
func (c *Client) ModifyOwnNumberApply(request *ModifyOwnNumberApplyRequest) (response *ModifyOwnNumberApplyResponse, err error) {
    return c.ModifyOwnNumberApplyWithContext(context.Background(), request)
}

// ModifyOwnNumberApply
// Modify customer's own number approval form
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INSTANCENOTEXIST = "InvalidParameter.InstanceNotExist"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_APPLYIDNOTEXIST = "InvalidParameterValue.ApplyIDNotExist"
//  INVALIDPARAMETERVALUE_ERRORAPPLYSTATUS = "InvalidParameterValue.ErrorApplyStatus"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMINVALID = "InvalidParameterValue.PhoneNumInvalid"
func (c *Client) ModifyOwnNumberApplyWithContext(ctx context.Context, request *ModifyOwnNumberApplyRequest) (response *ModifyOwnNumberApplyResponse, err error) {
    if request == nil {
        request = NewModifyOwnNumberApplyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ModifyOwnNumberApply")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyOwnNumberApply require credential")
    }

    request.SetContext(ctx)
    
    response = NewModifyOwnNumberApplyResponse()
    err = c.Send(request, response)
    return
}

func NewModifyStaffRequest() (request *ModifyStaffRequest) {
    request = &ModifyStaffRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ModifyStaff")
    
    
    return
}

func NewModifyStaffResponse() (response *ModifyStaffResponse) {
    response = &ModifyStaffResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyStaff
// This API is used to modify the customer service account.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMISBOUNDOTHERACCOUNT = "InvalidParameterValue.PhoneNumIsBoundOtherAccount"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
//  LIMITEXCEEDED_INSUFFICIENTLICENSE = "LimitExceeded.InsufficientLicense"
//  OPERATIONDENIED_NOTINWHITELIST = "OperationDenied.NotInWhiteList"
func (c *Client) ModifyStaff(request *ModifyStaffRequest) (response *ModifyStaffResponse, err error) {
    return c.ModifyStaffWithContext(context.Background(), request)
}

// ModifyStaff
// This API is used to modify the customer service account.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_PHONENUMISBOUNDOTHERACCOUNT = "InvalidParameterValue.PhoneNumIsBoundOtherAccount"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
//  LIMITEXCEEDED_INSUFFICIENTLICENSE = "LimitExceeded.InsufficientLicense"
//  OPERATIONDENIED_NOTINWHITELIST = "OperationDenied.NotInWhiteList"
func (c *Client) ModifyStaffWithContext(ctx context.Context, request *ModifyStaffRequest) (response *ModifyStaffResponse, err error) {
    if request == nil {
        request = NewModifyStaffRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ModifyStaff")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyStaff require credential")
    }

    request.SetContext(ctx)
    
    response = NewModifyStaffResponse()
    err = c.Send(request, response)
    return
}

func NewModifyStaffPasswordRequest() (request *ModifyStaffPasswordRequest) {
    request = &ModifyStaffPasswordRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ModifyStaffPassword")
    
    
    return
}

func NewModifyStaffPasswordResponse() (response *ModifyStaffPasswordResponse) {
    response = &ModifyStaffPasswordResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyStaffPassword
// Modify Agent's Password
//
// error code that may be returned:
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ModifyStaffPassword(request *ModifyStaffPasswordRequest) (response *ModifyStaffPasswordResponse, err error) {
    return c.ModifyStaffPasswordWithContext(context.Background(), request)
}

// ModifyStaffPassword
// Modify Agent's Password
//
// error code that may be returned:
//  INVALIDPARAMETERVALUE_ACCOUNTNOTEXIST = "InvalidParameterValue.AccountNotExist"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) ModifyStaffPasswordWithContext(ctx context.Context, request *ModifyStaffPasswordRequest) (response *ModifyStaffPasswordResponse, err error) {
    if request == nil {
        request = NewModifyStaffPasswordRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ModifyStaffPassword")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyStaffPassword require credential")
    }

    request.SetContext(ctx)
    
    response = NewModifyStaffPasswordResponse()
    err = c.Send(request, response)
    return
}

func NewPauseAutoCalloutTaskRequest() (request *PauseAutoCalloutTaskRequest) {
    request = &PauseAutoCalloutTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "PauseAutoCalloutTask")
    
    
    return
}

func NewPauseAutoCalloutTaskResponse() (response *PauseAutoCalloutTaskResponse) {
    response = &PauseAutoCalloutTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// PauseAutoCalloutTask
// This API is used to suspend an ongoing automatic outbound call task by TaskId. After calling this API, the task will be temporarily interrupted and no longer initiate new outbound call requests; initiated calls are not affected.
//
// A paused task can continue execution via the [Restore Suspended Automatic Outbound Call Task](https://www.tencentcloud.com/document/product/679/125356?from_cn_redirect=1) API. If needed, refer to [Stop Automatic Outbound Call Task](https://www.tencentcloud.com/document/product/679/69192?from_cn_redirect=1) to permanently terminate the task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) PauseAutoCalloutTask(request *PauseAutoCalloutTaskRequest) (response *PauseAutoCalloutTaskResponse, err error) {
    return c.PauseAutoCalloutTaskWithContext(context.Background(), request)
}

// PauseAutoCalloutTask
// This API is used to suspend an ongoing automatic outbound call task by TaskId. After calling this API, the task will be temporarily interrupted and no longer initiate new outbound call requests; initiated calls are not affected.
//
// A paused task can continue execution via the [Restore Suspended Automatic Outbound Call Task](https://www.tencentcloud.com/document/product/679/125356?from_cn_redirect=1) API. If needed, refer to [Stop Automatic Outbound Call Task](https://www.tencentcloud.com/document/product/679/69192?from_cn_redirect=1) to permanently terminate the task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) PauseAutoCalloutTaskWithContext(ctx context.Context, request *PauseAutoCalloutTaskRequest) (response *PauseAutoCalloutTaskResponse, err error) {
    if request == nil {
        request = NewPauseAutoCalloutTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "PauseAutoCalloutTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("PauseAutoCalloutTask require credential")
    }

    request.SetContext(ctx)
    
    response = NewPauseAutoCalloutTaskResponse()
    err = c.Send(request, response)
    return
}

func NewPausePredictiveDialingCampaignRequest() (request *PausePredictiveDialingCampaignRequest) {
    request = &PausePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "PausePredictiveDialingCampaign")
    
    
    return
}

func NewPausePredictiveDialingCampaignResponse() (response *PausePredictiveDialingCampaignResponse) {
    response = &PausePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// PausePredictiveDialingCampaign
// This API is used to pause the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) PausePredictiveDialingCampaign(request *PausePredictiveDialingCampaignRequest) (response *PausePredictiveDialingCampaignResponse, err error) {
    return c.PausePredictiveDialingCampaignWithContext(context.Background(), request)
}

// PausePredictiveDialingCampaign
// This API is used to pause the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) PausePredictiveDialingCampaignWithContext(ctx context.Context, request *PausePredictiveDialingCampaignRequest) (response *PausePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewPausePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "PausePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("PausePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewPausePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewPlaySoundCallRequest() (request *PlaySoundCallRequest) {
    request = &PlaySoundCallRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "PlaySoundCall")
    
    
    return
}

func NewPlaySoundCallResponse() (response *PlaySoundCallResponse) {
    response = &PlaySoundCallResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// PlaySoundCall
// This API is used to perform playback for a session in a call with an agent.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE_FILENOTEXIST = "InvalidParameterValue.FileNotExist"
func (c *Client) PlaySoundCall(request *PlaySoundCallRequest) (response *PlaySoundCallResponse, err error) {
    return c.PlaySoundCallWithContext(context.Background(), request)
}

// PlaySoundCall
// This API is used to perform playback for a session in a call with an agent.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE_FILENOTEXIST = "InvalidParameterValue.FileNotExist"
func (c *Client) PlaySoundCallWithContext(ctx context.Context, request *PlaySoundCallRequest) (response *PlaySoundCallResponse, err error) {
    if request == nil {
        request = NewPlaySoundCallRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "PlaySoundCall")
    
    if c.GetCredential() == nil {
        return nil, errors.New("PlaySoundCall require credential")
    }

    request.SetContext(ctx)
    
    response = NewPlaySoundCallResponse()
    err = c.Send(request, response)
    return
}

func NewResetExtensionPasswordRequest() (request *ResetExtensionPasswordRequest) {
    request = &ResetExtensionPasswordRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ResetExtensionPassword")
    
    
    return
}

func NewResetExtensionPasswordResponse() (response *ResetExtensionPasswordResponse) {
    response = &ResetExtensionPasswordResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ResetExtensionPassword
// This API is used to reset the telephone register password.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE_FILENOTEXIST = "InvalidParameterValue.FileNotExist"
func (c *Client) ResetExtensionPassword(request *ResetExtensionPasswordRequest) (response *ResetExtensionPasswordResponse, err error) {
    return c.ResetExtensionPasswordWithContext(context.Background(), request)
}

// ResetExtensionPassword
// This API is used to reset the telephone register password.
//
// error code that may be returned:
//  FAILEDOPERATION_PERMISSIONDENIED = "FailedOperation.PermissionDenied"
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  FAILEDOPERATION_SESSIONNOTINCONTROLSTATE = "FailedOperation.SessionNotInControlState"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE_FILENOTEXIST = "InvalidParameterValue.FileNotExist"
func (c *Client) ResetExtensionPasswordWithContext(ctx context.Context, request *ResetExtensionPasswordRequest) (response *ResetExtensionPasswordResponse, err error) {
    if request == nil {
        request = NewResetExtensionPasswordRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ResetExtensionPassword")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ResetExtensionPassword require credential")
    }

    request.SetContext(ctx)
    
    response = NewResetExtensionPasswordResponse()
    err = c.Send(request, response)
    return
}

func NewRestoreMemberOnlineRequest() (request *RestoreMemberOnlineRequest) {
    request = &RestoreMemberOnlineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "RestoreMemberOnline")
    
    
    return
}

func NewRestoreMemberOnlineResponse() (response *RestoreMemberOnlineResponse) {
    response = &RestoreMemberOnlineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RestoreMemberOnline
// This API is used to restore customer service to go live.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) RestoreMemberOnline(request *RestoreMemberOnlineRequest) (response *RestoreMemberOnlineResponse, err error) {
    return c.RestoreMemberOnlineWithContext(context.Background(), request)
}

// RestoreMemberOnline
// This API is used to restore customer service to go live.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) RestoreMemberOnlineWithContext(ctx context.Context, request *RestoreMemberOnlineRequest) (response *RestoreMemberOnlineResponse, err error) {
    if request == nil {
        request = NewRestoreMemberOnlineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "RestoreMemberOnline")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RestoreMemberOnline require credential")
    }

    request.SetContext(ctx)
    
    response = NewRestoreMemberOnlineResponse()
    err = c.Send(request, response)
    return
}

func NewResumeAutoCalloutTaskRequest() (request *ResumeAutoCalloutTaskRequest) {
    request = &ResumeAutoCalloutTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ResumeAutoCalloutTask")
    
    
    return
}

func NewResumeAutoCalloutTaskResponse() (response *ResumeAutoCalloutTaskResponse) {
    response = &ResumeAutoCalloutTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ResumeAutoCalloutTask
// This API is used to restore a paused automatic outbound call task by TaskId. This API is suitable for scenarios where you need to continue execution of the remaining outbound call plan after calling Suspend Automatic Outbound Call Task. After a successful call, the task will resume from the paused state and re-initiate incomplete outbound requests.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ResumeAutoCalloutTask(request *ResumeAutoCalloutTaskRequest) (response *ResumeAutoCalloutTaskResponse, err error) {
    return c.ResumeAutoCalloutTaskWithContext(context.Background(), request)
}

// ResumeAutoCalloutTask
// This API is used to restore a paused automatic outbound call task by TaskId. This API is suitable for scenarios where you need to continue execution of the remaining outbound call plan after calling Suspend Automatic Outbound Call Task. After a successful call, the task will resume from the paused state and re-initiate incomplete outbound requests.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ResumeAutoCalloutTaskWithContext(ctx context.Context, request *ResumeAutoCalloutTaskRequest) (response *ResumeAutoCalloutTaskResponse, err error) {
    if request == nil {
        request = NewResumeAutoCalloutTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ResumeAutoCalloutTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ResumeAutoCalloutTask require credential")
    }

    request.SetContext(ctx)
    
    response = NewResumeAutoCalloutTaskResponse()
    err = c.Send(request, response)
    return
}

func NewResumePredictiveDialingCampaignRequest() (request *ResumePredictiveDialingCampaignRequest) {
    request = &ResumePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "ResumePredictiveDialingCampaign")
    
    
    return
}

func NewResumePredictiveDialingCampaignResponse() (response *ResumePredictiveDialingCampaignResponse) {
    response = &ResumePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ResumePredictiveDialingCampaign
// This API is used to resume the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ResumePredictiveDialingCampaign(request *ResumePredictiveDialingCampaignRequest) (response *ResumePredictiveDialingCampaignResponse, err error) {
    return c.ResumePredictiveDialingCampaignWithContext(context.Background(), request)
}

// ResumePredictiveDialingCampaign
// This API is used to resume the predictive outbound call task.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ResumePredictiveDialingCampaignWithContext(ctx context.Context, request *ResumePredictiveDialingCampaignRequest) (response *ResumePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewResumePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "ResumePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ResumePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewResumePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewSetStaffStatusRequest() (request *SetStaffStatusRequest) {
    request = &SetStaffStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "SetStaffStatus")
    
    
    return
}

func NewSetStaffStatusResponse() (response *SetStaffStatusResponse) {
    response = &SetStaffStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SetStaffStatus
// This API is used to set staff status.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) SetStaffStatus(request *SetStaffStatusRequest) (response *SetStaffStatusResponse, err error) {
    return c.SetStaffStatusWithContext(context.Background(), request)
}

// SetStaffStatus
// This API is used to set staff status.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) SetStaffStatusWithContext(ctx context.Context, request *SetStaffStatusRequest) (response *SetStaffStatusResponse, err error) {
    if request == nil {
        request = NewSetStaffStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "SetStaffStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SetStaffStatus require credential")
    }

    request.SetContext(ctx)
    
    response = NewSetStaffStatusResponse()
    err = c.Send(request, response)
    return
}

func NewStopAutoCalloutTaskRequest() (request *StopAutoCalloutTaskRequest) {
    request = &StopAutoCalloutTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "StopAutoCalloutTask")
    
    
    return
}

func NewStopAutoCalloutTaskResponse() (response *StopAutoCalloutTaskResponse) {
    response = &StopAutoCalloutTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// StopAutoCalloutTask
// This API is used to stop the automatic outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) StopAutoCalloutTask(request *StopAutoCalloutTaskRequest) (response *StopAutoCalloutTaskResponse, err error) {
    return c.StopAutoCalloutTaskWithContext(context.Background(), request)
}

// StopAutoCalloutTask
// This API is used to stop the automatic outbound call task.
//
// error code that may be returned:
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) StopAutoCalloutTaskWithContext(ctx context.Context, request *StopAutoCalloutTaskRequest) (response *StopAutoCalloutTaskResponse, err error) {
    if request == nil {
        request = NewStopAutoCalloutTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "StopAutoCalloutTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("StopAutoCalloutTask require credential")
    }

    request.SetContext(ctx)
    
    response = NewStopAutoCalloutTaskResponse()
    err = c.Send(request, response)
    return
}

func NewTransferToManualRequest() (request *TransferToManualRequest) {
    request = &TransferToManualRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "TransferToManual")
    
    
    return
}

func NewTransferToManualResponse() (response *TransferToManualResponse) {
    response = &TransferToManualResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// TransferToManual
// This API is used to transfer a session to an agent in specific scenarios.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_RINGALLGROUPMEMBEROVERFLOW = "InvalidParameterValue.RingAllGroupMemberOverflow"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
func (c *Client) TransferToManual(request *TransferToManualRequest) (response *TransferToManualResponse, err error) {
    return c.TransferToManualWithContext(context.Background(), request)
}

// TransferToManual
// This API is used to transfer a session to an agent in specific scenarios.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_RINGALLGROUPMEMBEROVERFLOW = "InvalidParameterValue.RingAllGroupMemberOverflow"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
func (c *Client) TransferToManualWithContext(ctx context.Context, request *TransferToManualRequest) (response *TransferToManualResponse, err error) {
    if request == nil {
        request = NewTransferToManualRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "TransferToManual")
    
    if c.GetCredential() == nil {
        return nil, errors.New("TransferToManual require credential")
    }

    request.SetContext(ctx)
    
    response = NewTransferToManualResponse()
    err = c.Send(request, response)
    return
}

func NewUnbindNumberCallOutSkillGroupRequest() (request *UnbindNumberCallOutSkillGroupRequest) {
    request = &UnbindNumberCallOutSkillGroupRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "UnbindNumberCallOutSkillGroup")
    
    
    return
}

func NewUnbindNumberCallOutSkillGroupResponse() (response *UnbindNumberCallOutSkillGroupResponse) {
    response = &UnbindNumberCallOutSkillGroupResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UnbindNumberCallOutSkillGroup
// This API is used to unbind the number from the outbound call skill group.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_RINGALLGROUPMEMBEROVERFLOW = "InvalidParameterValue.RingAllGroupMemberOverflow"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
func (c *Client) UnbindNumberCallOutSkillGroup(request *UnbindNumberCallOutSkillGroupRequest) (response *UnbindNumberCallOutSkillGroupResponse, err error) {
    return c.UnbindNumberCallOutSkillGroupWithContext(context.Background(), request)
}

// UnbindNumberCallOutSkillGroup
// This API is used to unbind the number from the outbound call skill group.
//
// error code that may be returned:
//  FAILEDOPERATION_SESSIONNOTEXISTS = "FailedOperation.SessionNotExists"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
//  INVALIDPARAMETERVALUE_RINGALLGROUPMEMBEROVERFLOW = "InvalidParameterValue.RingAllGroupMemberOverflow"
//  INVALIDPARAMETERVALUE_SKILLGROUPERROR = "InvalidParameterValue.SkillGroupError"
func (c *Client) UnbindNumberCallOutSkillGroupWithContext(ctx context.Context, request *UnbindNumberCallOutSkillGroupRequest) (response *UnbindNumberCallOutSkillGroupResponse, err error) {
    if request == nil {
        request = NewUnbindNumberCallOutSkillGroupRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "UnbindNumberCallOutSkillGroup")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UnbindNumberCallOutSkillGroup require credential")
    }

    request.SetContext(ctx)
    
    response = NewUnbindNumberCallOutSkillGroupResponse()
    err = c.Send(request, response)
    return
}

func NewUnbindStaffSkillGroupListRequest() (request *UnbindStaffSkillGroupListRequest) {
    request = &UnbindStaffSkillGroupListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "UnbindStaffSkillGroupList")
    
    
    return
}

func NewUnbindStaffSkillGroupListResponse() (response *UnbindStaffSkillGroupListResponse) {
    response = &UnbindStaffSkillGroupListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UnbindStaffSkillGroupList
// This API is used to unbind the agent's skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) UnbindStaffSkillGroupList(request *UnbindStaffSkillGroupListRequest) (response *UnbindStaffSkillGroupListResponse, err error) {
    return c.UnbindStaffSkillGroupListWithContext(context.Background(), request)
}

// UnbindStaffSkillGroupList
// This API is used to unbind the agent's skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_INSTANCENOTEXIST = "InvalidParameterValue.InstanceNotExist"
func (c *Client) UnbindStaffSkillGroupListWithContext(ctx context.Context, request *UnbindStaffSkillGroupListRequest) (response *UnbindStaffSkillGroupListResponse, err error) {
    if request == nil {
        request = NewUnbindStaffSkillGroupListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "UnbindStaffSkillGroupList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UnbindStaffSkillGroupList require credential")
    }

    request.SetContext(ctx)
    
    response = NewUnbindStaffSkillGroupListResponse()
    err = c.Send(request, response)
    return
}

func NewUpdateCCCSkillGroupRequest() (request *UpdateCCCSkillGroupRequest) {
    request = &UpdateCCCSkillGroupRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "UpdateCCCSkillGroup")
    
    
    return
}

func NewUpdateCCCSkillGroupResponse() (response *UpdateCCCSkillGroupResponse) {
    response = &UpdateCCCSkillGroupResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UpdateCCCSkillGroup
// This API is used to update the skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_SKILLGROUPEXIST = "InvalidParameterValue.SkillGroupExist"
func (c *Client) UpdateCCCSkillGroup(request *UpdateCCCSkillGroupRequest) (response *UpdateCCCSkillGroupResponse, err error) {
    return c.UpdateCCCSkillGroupWithContext(context.Background(), request)
}

// UpdateCCCSkillGroup
// This API is used to update the skill group.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE_SKILLGROUPEXIST = "InvalidParameterValue.SkillGroupExist"
func (c *Client) UpdateCCCSkillGroupWithContext(ctx context.Context, request *UpdateCCCSkillGroupRequest) (response *UpdateCCCSkillGroupResponse, err error) {
    if request == nil {
        request = NewUpdateCCCSkillGroupRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "UpdateCCCSkillGroup")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UpdateCCCSkillGroup require credential")
    }

    request.SetContext(ctx)
    
    response = NewUpdateCCCSkillGroupResponse()
    err = c.Send(request, response)
    return
}

func NewUpdatePredictiveDialingCampaignRequest() (request *UpdatePredictiveDialingCampaignRequest) {
    request = &UpdatePredictiveDialingCampaignRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "UpdatePredictiveDialingCampaign")
    
    
    return
}

func NewUpdatePredictiveDialingCampaignResponse() (response *UpdatePredictiveDialingCampaignResponse) {
    response = &UpdatePredictiveDialingCampaignResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UpdatePredictiveDialingCampaign
// This API is used to update the predictive outbound call task before it starts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) UpdatePredictiveDialingCampaign(request *UpdatePredictiveDialingCampaignRequest) (response *UpdatePredictiveDialingCampaignResponse, err error) {
    return c.UpdatePredictiveDialingCampaignWithContext(context.Background(), request)
}

// UpdatePredictiveDialingCampaign
// This API is used to update the predictive outbound call task before it starts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) UpdatePredictiveDialingCampaignWithContext(ctx context.Context, request *UpdatePredictiveDialingCampaignRequest) (response *UpdatePredictiveDialingCampaignResponse, err error) {
    if request == nil {
        request = NewUpdatePredictiveDialingCampaignRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "UpdatePredictiveDialingCampaign")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UpdatePredictiveDialingCampaign require credential")
    }

    request.SetContext(ctx)
    
    response = NewUpdatePredictiveDialingCampaignResponse()
    err = c.Send(request, response)
    return
}

func NewUploadIvrAudioRequest() (request *UploadIvrAudioRequest) {
    request = &UploadIvrAudioRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("ccc", APIVersion, "UploadIvrAudio")
    
    
    return
}

func NewUploadIvrAudioResponse() (response *UploadIvrAudioResponse) {
    response = &UploadIvrAudioResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UploadIvrAudio
// Upload audio files used in IVR, with a daily upload limit of 50 files. (It is recommended to use temporary links stored in Tencent Cloud Cos for the audio file URL in the parameters)
//
// error code that may be returned:
//  FAILEDOPERATION_UPLOADFILEOVERFLOW = "FailedOperation.UploadFileOverflow"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) UploadIvrAudio(request *UploadIvrAudioRequest) (response *UploadIvrAudioResponse, err error) {
    return c.UploadIvrAudioWithContext(context.Background(), request)
}

// UploadIvrAudio
// Upload audio files used in IVR, with a daily upload limit of 50 files. (It is recommended to use temporary links stored in Tencent Cloud Cos for the audio file URL in the parameters)
//
// error code that may be returned:
//  FAILEDOPERATION_UPLOADFILEOVERFLOW = "FailedOperation.UploadFileOverflow"
//  INTERNALERROR_DBERROR = "InternalError.DBError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) UploadIvrAudioWithContext(ctx context.Context, request *UploadIvrAudioRequest) (response *UploadIvrAudioResponse, err error) {
    if request == nil {
        request = NewUploadIvrAudioRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "ccc", APIVersion, "UploadIvrAudio")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UploadIvrAudio require credential")
    }

    request.SetContext(ctx)
    
    response = NewUploadIvrAudioResponse()
    err = c.Send(request, response)
    return
}
