// 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 v20180228

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 = "2018-02-28"

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 NewAddLoginWhiteListsRequest() (request *AddLoginWhiteListsRequest) {
    request = &AddLoginWhiteListsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "AddLoginWhiteLists")
    
    
    return
}

func NewAddLoginWhiteListsResponse() (response *AddLoginWhiteListsResponse) {
    response = &AddLoginWhiteListsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// AddLoginWhiteLists
// This API is used to add cross-region log-in allowlists in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) AddLoginWhiteLists(request *AddLoginWhiteListsRequest) (response *AddLoginWhiteListsResponse, err error) {
    return c.AddLoginWhiteListsWithContext(context.Background(), request)
}

// AddLoginWhiteLists
// This API is used to add cross-region log-in allowlists in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) AddLoginWhiteListsWithContext(ctx context.Context, request *AddLoginWhiteListsRequest) (response *AddLoginWhiteListsResponse, err error) {
    if request == nil {
        request = NewAddLoginWhiteListsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "AddLoginWhiteLists")
    
    if c.GetCredential() == nil {
        return nil, errors.New("AddLoginWhiteLists require credential")
    }

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

func NewCancelIgnoreVulRequest() (request *CancelIgnoreVulRequest) {
    request = &CancelIgnoreVulRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CancelIgnoreVul")
    
    
    return
}

func NewCancelIgnoreVulResponse() (response *CancelIgnoreVulResponse) {
    response = &CancelIgnoreVulResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CancelIgnoreVul
// This API is used to unignore the vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CancelIgnoreVul(request *CancelIgnoreVulRequest) (response *CancelIgnoreVulResponse, err error) {
    return c.CancelIgnoreVulWithContext(context.Background(), request)
}

// CancelIgnoreVul
// This API is used to unignore the vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CancelIgnoreVulWithContext(ctx context.Context, request *CancelIgnoreVulRequest) (response *CancelIgnoreVulResponse, err error) {
    if request == nil {
        request = NewCancelIgnoreVulRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CancelIgnoreVul")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CancelIgnoreVul require credential")
    }

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

func NewChangeRuleEventsIgnoreStatusRequest() (request *ChangeRuleEventsIgnoreStatusRequest) {
    request = &ChangeRuleEventsIgnoreStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ChangeRuleEventsIgnoreStatus")
    
    
    return
}

func NewChangeRuleEventsIgnoreStatusResponse() (response *ChangeRuleEventsIgnoreStatusResponse) {
    response = &ChangeRuleEventsIgnoreStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ChangeRuleEventsIgnoreStatus
// This API is used to ignore events or cancel ignoring in batches based on check item ID or event ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ChangeRuleEventsIgnoreStatus(request *ChangeRuleEventsIgnoreStatusRequest) (response *ChangeRuleEventsIgnoreStatusResponse, err error) {
    return c.ChangeRuleEventsIgnoreStatusWithContext(context.Background(), request)
}

// ChangeRuleEventsIgnoreStatus
// This API is used to ignore events or cancel ignoring in batches based on check item ID or event ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ChangeRuleEventsIgnoreStatusWithContext(ctx context.Context, request *ChangeRuleEventsIgnoreStatusRequest) (response *ChangeRuleEventsIgnoreStatusResponse, err error) {
    if request == nil {
        request = NewChangeRuleEventsIgnoreStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ChangeRuleEventsIgnoreStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ChangeRuleEventsIgnoreStatus require credential")
    }

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

func NewChangeStrategyEnableStatusRequest() (request *ChangeStrategyEnableStatusRequest) {
    request = &ChangeStrategyEnableStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ChangeStrategyEnableStatus")
    
    
    return
}

func NewChangeStrategyEnableStatusResponse() (response *ChangeStrategyEnableStatusResponse) {
    response = &ChangeStrategyEnableStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ChangeStrategyEnableStatus
// This API is used to change the policy availability status by policy ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ChangeStrategyEnableStatus(request *ChangeStrategyEnableStatusRequest) (response *ChangeStrategyEnableStatusResponse, err error) {
    return c.ChangeStrategyEnableStatusWithContext(context.Background(), request)
}

// ChangeStrategyEnableStatus
// This API is used to change the policy availability status by policy ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ChangeStrategyEnableStatusWithContext(ctx context.Context, request *ChangeStrategyEnableStatusRequest) (response *ChangeStrategyEnableStatusResponse, err error) {
    if request == nil {
        request = NewChangeStrategyEnableStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ChangeStrategyEnableStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ChangeStrategyEnableStatus require credential")
    }

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

func NewCheckBashPolicyParamsRequest() (request *CheckBashPolicyParamsRequest) {
    request = &CheckBashPolicyParamsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CheckBashPolicyParams")
    
    
    return
}

func NewCheckBashPolicyParamsResponse() (response *CheckBashPolicyParamsResponse) {
    response = &CheckBashPolicyParamsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CheckBashPolicyParams
// This API is used to verify parameters entered for adding and editing high-risk command user rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckBashPolicyParams(request *CheckBashPolicyParamsRequest) (response *CheckBashPolicyParamsResponse, err error) {
    return c.CheckBashPolicyParamsWithContext(context.Background(), request)
}

// CheckBashPolicyParams
// This API is used to verify parameters entered for adding and editing high-risk command user rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckBashPolicyParamsWithContext(ctx context.Context, request *CheckBashPolicyParamsRequest) (response *CheckBashPolicyParamsResponse, err error) {
    if request == nil {
        request = NewCheckBashPolicyParamsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CheckBashPolicyParams")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CheckBashPolicyParams require credential")
    }

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

func NewCheckBashRuleParamsRequest() (request *CheckBashRuleParamsRequest) {
    request = &CheckBashRuleParamsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CheckBashRuleParams")
    
    
    return
}

func NewCheckBashRuleParamsResponse() (response *CheckBashRuleParamsResponse) {
    response = &CheckBashRuleParamsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CheckBashRuleParams
// This API is used to verify parameters entered for adding and editing high-risk command user rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckBashRuleParams(request *CheckBashRuleParamsRequest) (response *CheckBashRuleParamsResponse, err error) {
    return c.CheckBashRuleParamsWithContext(context.Background(), request)
}

// CheckBashRuleParams
// This API is used to verify parameters entered for adding and editing high-risk command user rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckBashRuleParamsWithContext(ctx context.Context, request *CheckBashRuleParamsRequest) (response *CheckBashRuleParamsResponse, err error) {
    if request == nil {
        request = NewCheckBashRuleParamsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CheckBashRuleParams")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CheckBashRuleParams require credential")
    }

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

func NewCheckFileTamperRuleRequest() (request *CheckFileTamperRuleRequest) {
    request = &CheckFileTamperRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CheckFileTamperRule")
    
    
    return
}

func NewCheckFileTamperRuleResponse() (response *CheckFileTamperRuleResponse) {
    response = &CheckFileTamperRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CheckFileTamperRule
// This API is used to check the rule parameters entered at the core file monitoring frontend.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckFileTamperRule(request *CheckFileTamperRuleRequest) (response *CheckFileTamperRuleResponse, err error) {
    return c.CheckFileTamperRuleWithContext(context.Background(), request)
}

// CheckFileTamperRule
// This API is used to check the rule parameters entered at the core file monitoring frontend.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) CheckFileTamperRuleWithContext(ctx context.Context, request *CheckFileTamperRuleRequest) (response *CheckFileTamperRuleResponse, err error) {
    if request == nil {
        request = NewCheckFileTamperRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CheckFileTamperRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CheckFileTamperRule require credential")
    }

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

func NewCheckFirstScanBaselineRequest() (request *CheckFirstScanBaselineRequest) {
    request = &CheckFirstScanBaselineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CheckFirstScanBaseline")
    
    
    return
}

func NewCheckFirstScanBaselineResponse() (response *CheckFirstScanBaselineResponse) {
    response = &CheckFirstScanBaselineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CheckFirstScanBaseline
// This API is used to query whether the baseline is detected for the first time.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) CheckFirstScanBaseline(request *CheckFirstScanBaselineRequest) (response *CheckFirstScanBaselineResponse, err error) {
    return c.CheckFirstScanBaselineWithContext(context.Background(), request)
}

// CheckFirstScanBaseline
// This API is used to query whether the baseline is detected for the first time.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) CheckFirstScanBaselineWithContext(ctx context.Context, request *CheckFirstScanBaselineRequest) (response *CheckFirstScanBaselineResponse, err error) {
    if request == nil {
        request = NewCheckFirstScanBaselineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CheckFirstScanBaseline")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CheckFirstScanBaseline require credential")
    }

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

func NewCheckLogKafkaConnectionStateRequest() (request *CheckLogKafkaConnectionStateRequest) {
    request = &CheckLogKafkaConnectionStateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CheckLogKafkaConnectionState")
    
    
    return
}

func NewCheckLogKafkaConnectionStateResponse() (response *CheckLogKafkaConnectionStateResponse) {
    response = &CheckLogKafkaConnectionStateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CheckLogKafkaConnectionState
// This API is used to check the connectivity for log shipping from Kafka.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
func (c *Client) CheckLogKafkaConnectionState(request *CheckLogKafkaConnectionStateRequest) (response *CheckLogKafkaConnectionStateResponse, err error) {
    return c.CheckLogKafkaConnectionStateWithContext(context.Background(), request)
}

// CheckLogKafkaConnectionState
// This API is used to check the connectivity for log shipping from Kafka.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
func (c *Client) CheckLogKafkaConnectionStateWithContext(ctx context.Context, request *CheckLogKafkaConnectionStateRequest) (response *CheckLogKafkaConnectionStateResponse, err error) {
    if request == nil {
        request = NewCheckLogKafkaConnectionStateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CheckLogKafkaConnectionState")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CheckLogKafkaConnectionState require credential")
    }

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

func NewClearLocalStorageRequest() (request *ClearLocalStorageRequest) {
    request = &ClearLocalStorageRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ClearLocalStorage")
    
    
    return
}

func NewClearLocalStorageResponse() (response *ClearLocalStorageResponse) {
    response = &ClearLocalStorageResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ClearLocalStorage
// This API is used to clean up the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ClearLocalStorage(request *ClearLocalStorageRequest) (response *ClearLocalStorageResponse, err error) {
    return c.ClearLocalStorageWithContext(context.Background(), request)
}

// ClearLocalStorage
// This API is used to clean up the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ClearLocalStorageWithContext(ctx context.Context, request *ClearLocalStorageRequest) (response *ClearLocalStorageResponse, err error) {
    if request == nil {
        request = NewClearLocalStorageRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ClearLocalStorage")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ClearLocalStorage require credential")
    }

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

func NewCreateBanWhiteListRequest() (request *CreateBanWhiteListRequest) {
    request = &CreateBanWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateBanWhiteList")
    
    
    return
}

func NewCreateBanWhiteListResponse() (response *CreateBanWhiteListResponse) {
    response = &CreateBanWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateBanWhiteList
// This API is used to add the list of block allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateBanWhiteList(request *CreateBanWhiteListRequest) (response *CreateBanWhiteListResponse, err error) {
    return c.CreateBanWhiteListWithContext(context.Background(), request)
}

// CreateBanWhiteList
// This API is used to add the list of block allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateBanWhiteListWithContext(ctx context.Context, request *CreateBanWhiteListRequest) (response *CreateBanWhiteListResponse, err error) {
    if request == nil {
        request = NewCreateBanWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateBanWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateBanWhiteList require credential")
    }

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

func NewCreateBaselineStrategyRequest() (request *CreateBaselineStrategyRequest) {
    request = &CreateBaselineStrategyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateBaselineStrategy")
    
    
    return
}

func NewCreateBaselineStrategyResponse() (response *CreateBaselineStrategyResponse) {
    response = &CreateBaselineStrategyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateBaselineStrategy
// This API is used to create a baseline policy based on the policy information.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  FAILEDOPERATION_TOOMANYSTRATEGY = "FailedOperation.TooManyStrategy"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateBaselineStrategy(request *CreateBaselineStrategyRequest) (response *CreateBaselineStrategyResponse, err error) {
    return c.CreateBaselineStrategyWithContext(context.Background(), request)
}

// CreateBaselineStrategy
// This API is used to create a baseline policy based on the policy information.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  FAILEDOPERATION_TOOMANYSTRATEGY = "FailedOperation.TooManyStrategy"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateBaselineStrategyWithContext(ctx context.Context, request *CreateBaselineStrategyRequest) (response *CreateBaselineStrategyResponse, err error) {
    if request == nil {
        request = NewCreateBaselineStrategyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateBaselineStrategy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateBaselineStrategy require credential")
    }

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

func NewCreateBuyBindTaskRequest() (request *CreateBuyBindTaskRequest) {
    request = &CreateBuyBindTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateBuyBindTask")
    
    
    return
}

func NewCreateBuyBindTaskResponse() (response *CreateBuyBindTaskResponse) {
    response = &CreateBuyBindTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateBuyBindTask
// This API is used to create an automatic binding task for newly purchased authorizations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateBuyBindTask(request *CreateBuyBindTaskRequest) (response *CreateBuyBindTaskResponse, err error) {
    return c.CreateBuyBindTaskWithContext(context.Background(), request)
}

// CreateBuyBindTask
// This API is used to create an automatic binding task for newly purchased authorizations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateBuyBindTaskWithContext(ctx context.Context, request *CreateBuyBindTaskRequest) (response *CreateBuyBindTaskResponse, err error) {
    if request == nil {
        request = NewCreateBuyBindTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateBuyBindTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateBuyBindTask require credential")
    }

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

func NewCreateEmergencyVulScanRequest() (request *CreateEmergencyVulScanRequest) {
    request = &CreateEmergencyVulScanRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateEmergencyVulScan")
    
    
    return
}

func NewCreateEmergencyVulScanResponse() (response *CreateEmergencyVulScanResponse) {
    response = &CreateEmergencyVulScanResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateEmergencyVulScan
// This API is used to create emergency vulnerability scan tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateEmergencyVulScan(request *CreateEmergencyVulScanRequest) (response *CreateEmergencyVulScanResponse, err error) {
    return c.CreateEmergencyVulScanWithContext(context.Background(), request)
}

// CreateEmergencyVulScan
// This API is used to create emergency vulnerability scan tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateEmergencyVulScanWithContext(ctx context.Context, request *CreateEmergencyVulScanRequest) (response *CreateEmergencyVulScanResponse, err error) {
    if request == nil {
        request = NewCreateEmergencyVulScanRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateEmergencyVulScan")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateEmergencyVulScan require credential")
    }

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

func NewCreateIncidentBacktrackingRequest() (request *CreateIncidentBacktrackingRequest) {
    request = &CreateIncidentBacktrackingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateIncidentBacktracking")
    
    
    return
}

func NewCreateIncidentBacktrackingResponse() (response *CreateIncidentBacktrackingResponse) {
    response = &CreateIncidentBacktrackingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateIncidentBacktracking
// This API is used to trigger event investigation and alarm backtracking for Ultimate Edition machines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateIncidentBacktracking(request *CreateIncidentBacktrackingRequest) (response *CreateIncidentBacktrackingResponse, err error) {
    return c.CreateIncidentBacktrackingWithContext(context.Background(), request)
}

// CreateIncidentBacktracking
// This API is used to trigger event investigation and alarm backtracking for Ultimate Edition machines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateIncidentBacktrackingWithContext(ctx context.Context, request *CreateIncidentBacktrackingRequest) (response *CreateIncidentBacktrackingResponse, err error) {
    if request == nil {
        request = NewCreateIncidentBacktrackingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateIncidentBacktracking")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateIncidentBacktracking require credential")
    }

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

func NewCreateLicenseOrderRequest() (request *CreateLicenseOrderRequest) {
    request = &CreateLicenseOrderRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateLicenseOrder")
    
    
    return
}

func NewCreateLicenseOrderResponse() (response *CreateLicenseOrderResponse) {
    response = &CreateLicenseOrderResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateLicenseOrder
// This API is used to create Professional/Flagship edition orders
//
// .This API is used to support creating orders through prepaid and pay-as-you-go.
//
// This API is used to directly create postpaid orders.
//
// This API is used to call the billing payment API for payment since prepaid orders are only placed but not paid.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateLicenseOrder(request *CreateLicenseOrderRequest) (response *CreateLicenseOrderResponse, err error) {
    return c.CreateLicenseOrderWithContext(context.Background(), request)
}

// CreateLicenseOrder
// This API is used to create Professional/Flagship edition orders
//
// .This API is used to support creating orders through prepaid and pay-as-you-go.
//
// This API is used to directly create postpaid orders.
//
// This API is used to call the billing payment API for payment since prepaid orders are only placed but not paid.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateLicenseOrderWithContext(ctx context.Context, request *CreateLicenseOrderRequest) (response *CreateLicenseOrderResponse, err error) {
    if request == nil {
        request = NewCreateLicenseOrderRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateLicenseOrder")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateLicenseOrder require credential")
    }

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

func NewCreateLogExportRequest() (request *CreateLogExportRequest) {
    request = &CreateLogExportRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateLogExport")
    
    
    return
}

func NewCreateLogExportResponse() (response *CreateLogExportResponse) {
    response = &CreateLogExportResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateLogExport
// This API is used to create log download tasks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateLogExport(request *CreateLogExportRequest) (response *CreateLogExportResponse, err error) {
    return c.CreateLogExportWithContext(context.Background(), request)
}

// CreateLogExport
// This API is used to create log download tasks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateLogExportWithContext(ctx context.Context, request *CreateLogExportRequest) (response *CreateLogExportResponse, err error) {
    if request == nil {
        request = NewCreateLogExportRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateLogExport")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateLogExport require credential")
    }

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

func NewCreateMaliciousRequestWhiteListRequest() (request *CreateMaliciousRequestWhiteListRequest) {
    request = &CreateMaliciousRequestWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateMaliciousRequestWhiteList")
    
    
    return
}

func NewCreateMaliciousRequestWhiteListResponse() (response *CreateMaliciousRequestWhiteListResponse) {
    response = &CreateMaliciousRequestWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateMaliciousRequestWhiteList
// This API is used to add malicious request allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateMaliciousRequestWhiteList(request *CreateMaliciousRequestWhiteListRequest) (response *CreateMaliciousRequestWhiteListResponse, err error) {
    return c.CreateMaliciousRequestWhiteListWithContext(context.Background(), request)
}

// CreateMaliciousRequestWhiteList
// This API is used to add malicious request allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateMaliciousRequestWhiteListWithContext(ctx context.Context, request *CreateMaliciousRequestWhiteListRequest) (response *CreateMaliciousRequestWhiteListResponse, err error) {
    if request == nil {
        request = NewCreateMaliciousRequestWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateMaliciousRequestWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateMaliciousRequestWhiteList require credential")
    }

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

func NewCreateMalwareWhiteListRequest() (request *CreateMalwareWhiteListRequest) {
    request = &CreateMalwareWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateMalwareWhiteList")
    
    
    return
}

func NewCreateMalwareWhiteListResponse() (response *CreateMalwareWhiteListResponse) {
    response = &CreateMalwareWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateMalwareWhiteList
// This API is used to create the Trojan allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) CreateMalwareWhiteList(request *CreateMalwareWhiteListRequest) (response *CreateMalwareWhiteListResponse, err error) {
    return c.CreateMalwareWhiteListWithContext(context.Background(), request)
}

// CreateMalwareWhiteList
// This API is used to create the Trojan allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) CreateMalwareWhiteListWithContext(ctx context.Context, request *CreateMalwareWhiteListRequest) (response *CreateMalwareWhiteListResponse, err error) {
    if request == nil {
        request = NewCreateMalwareWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateMalwareWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateMalwareWhiteList require credential")
    }

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

func NewCreateNetAttackWhiteListRequest() (request *CreateNetAttackWhiteListRequest) {
    request = &CreateNetAttackWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateNetAttackWhiteList")
    
    
    return
}

func NewCreateNetAttackWhiteListResponse() (response *CreateNetAttackWhiteListResponse) {
    response = &CreateNetAttackWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateNetAttackWhiteList
// This API is used to create a network attack allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) CreateNetAttackWhiteList(request *CreateNetAttackWhiteListRequest) (response *CreateNetAttackWhiteListResponse, err error) {
    return c.CreateNetAttackWhiteListWithContext(context.Background(), request)
}

// CreateNetAttackWhiteList
// This API is used to create a network attack allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) CreateNetAttackWhiteListWithContext(ctx context.Context, request *CreateNetAttackWhiteListRequest) (response *CreateNetAttackWhiteListResponse, err error) {
    if request == nil {
        request = NewCreateNetAttackWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateNetAttackWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateNetAttackWhiteList require credential")
    }

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

func NewCreateRansomDefenseStrategyRequest() (request *CreateRansomDefenseStrategyRequest) {
    request = &CreateRansomDefenseStrategyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateRansomDefenseStrategy")
    
    
    return
}

func NewCreateRansomDefenseStrategyResponse() (response *CreateRansomDefenseStrategyResponse) {
    response = &CreateRansomDefenseStrategyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateRansomDefenseStrategy
// This API is used to create or modify anti-ransomware policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateRansomDefenseStrategy(request *CreateRansomDefenseStrategyRequest) (response *CreateRansomDefenseStrategyResponse, err error) {
    return c.CreateRansomDefenseStrategyWithContext(context.Background(), request)
}

// CreateRansomDefenseStrategy
// This API is used to create or modify anti-ransomware policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateRansomDefenseStrategyWithContext(ctx context.Context, request *CreateRansomDefenseStrategyRequest) (response *CreateRansomDefenseStrategyResponse, err error) {
    if request == nil {
        request = NewCreateRansomDefenseStrategyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateRansomDefenseStrategy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateRansomDefenseStrategy require credential")
    }

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

func NewCreateScanMalwareSettingRequest() (request *CreateScanMalwareSettingRequest) {
    request = &CreateScanMalwareSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateScanMalwareSetting")
    
    
    return
}

func NewCreateScanMalwareSettingResponse() (response *CreateScanMalwareSettingResponse) {
    response = &CreateScanMalwareSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateScanMalwareSetting
// This API is used to detect the intrusion and virus scanning.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateScanMalwareSetting(request *CreateScanMalwareSettingRequest) (response *CreateScanMalwareSettingResponse, err error) {
    return c.CreateScanMalwareSettingWithContext(context.Background(), request)
}

// CreateScanMalwareSetting
// This API is used to detect the intrusion and virus scanning.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateScanMalwareSettingWithContext(ctx context.Context, request *CreateScanMalwareSettingRequest) (response *CreateScanMalwareSettingResponse, err error) {
    if request == nil {
        request = NewCreateScanMalwareSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateScanMalwareSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateScanMalwareSetting require credential")
    }

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

func NewCreateSearchLogRequest() (request *CreateSearchLogRequest) {
    request = &CreateSearchLogRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateSearchLog")
    
    
    return
}

func NewCreateSearchLogResponse() (response *CreateSearchLogResponse) {
    response = &CreateSearchLogResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateSearchLog
// This API is used to add history search records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateSearchLog(request *CreateSearchLogRequest) (response *CreateSearchLogResponse, err error) {
    return c.CreateSearchLogWithContext(context.Background(), request)
}

// CreateSearchLog
// This API is used to add history search records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateSearchLogWithContext(ctx context.Context, request *CreateSearchLogRequest) (response *CreateSearchLogResponse, err error) {
    if request == nil {
        request = NewCreateSearchLogRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateSearchLog")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateSearchLog require credential")
    }

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

func NewCreateSearchTemplateRequest() (request *CreateSearchTemplateRequest) {
    request = &CreateSearchTemplateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateSearchTemplate")
    
    
    return
}

func NewCreateSearchTemplateResponse() (response *CreateSearchTemplateResponse) {
    response = &CreateSearchTemplateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateSearchTemplate
// This API is used to add the	retrieval template.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_NAMEHASREPETITION = "InvalidParameter.NameHasRepetition"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateSearchTemplate(request *CreateSearchTemplateRequest) (response *CreateSearchTemplateResponse, err error) {
    return c.CreateSearchTemplateWithContext(context.Background(), request)
}

// CreateSearchTemplate
// This API is used to add the	retrieval template.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_NAMEHASREPETITION = "InvalidParameter.NameHasRepetition"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) CreateSearchTemplateWithContext(ctx context.Context, request *CreateSearchTemplateRequest) (response *CreateSearchTemplateResponse, err error) {
    if request == nil {
        request = NewCreateSearchTemplateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateSearchTemplate")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateSearchTemplate require credential")
    }

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

func NewCreateVulFixRequest() (request *CreateVulFixRequest) {
    request = &CreateVulFixRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateVulFix")
    
    
    return
}

func NewCreateVulFixResponse() (response *CreateVulFixResponse) {
    response = &CreateVulFixResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateVulFix
// This API is used to submit the vulnerabilities and fix them.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateVulFix(request *CreateVulFixRequest) (response *CreateVulFixResponse, err error) {
    return c.CreateVulFixWithContext(context.Background(), request)
}

// CreateVulFix
// This API is used to submit the vulnerabilities and fix them.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) CreateVulFixWithContext(ctx context.Context, request *CreateVulFixRequest) (response *CreateVulFixResponse, err error) {
    if request == nil {
        request = NewCreateVulFixRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateVulFix")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateVulFix require credential")
    }

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

func NewCreateWhiteListOrderRequest() (request *CreateWhiteListOrderRequest) {
    request = &CreateWhiteListOrderRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "CreateWhiteListOrder")
    
    
    return
}

func NewCreateWhiteListOrderResponse() (response *CreateWhiteListOrderResponse) {
    response = &CreateWhiteListOrderResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// CreateWhiteListOrder
// This API is used to create allowlist orders.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateWhiteListOrder(request *CreateWhiteListOrderRequest) (response *CreateWhiteListOrderResponse, err error) {
    return c.CreateWhiteListOrderWithContext(context.Background(), request)
}

// CreateWhiteListOrder
// This API is used to create allowlist orders.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) CreateWhiteListOrderWithContext(ctx context.Context, request *CreateWhiteListOrderRequest) (response *CreateWhiteListOrderResponse, err error) {
    if request == nil {
        request = NewCreateWhiteListOrderRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "CreateWhiteListOrder")
    
    if c.GetCredential() == nil {
        return nil, errors.New("CreateWhiteListOrder require credential")
    }

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

func NewDeleteAllJavaMemShellsRequest() (request *DeleteAllJavaMemShellsRequest) {
    request = &DeleteAllJavaMemShellsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteAllJavaMemShells")
    
    
    return
}

func NewDeleteAllJavaMemShellsResponse() (response *DeleteAllJavaMemShellsResponse) {
    response = &DeleteAllJavaMemShellsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteAllJavaMemShells
// This API is used to delete all Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteAllJavaMemShells(request *DeleteAllJavaMemShellsRequest) (response *DeleteAllJavaMemShellsResponse, err error) {
    return c.DeleteAllJavaMemShellsWithContext(context.Background(), request)
}

// DeleteAllJavaMemShells
// This API is used to delete all Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteAllJavaMemShellsWithContext(ctx context.Context, request *DeleteAllJavaMemShellsRequest) (response *DeleteAllJavaMemShellsResponse, err error) {
    if request == nil {
        request = NewDeleteAllJavaMemShellsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteAllJavaMemShells")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteAllJavaMemShells require credential")
    }

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

func NewDeleteBanWhiteListRequest() (request *DeleteBanWhiteListRequest) {
    request = &DeleteBanWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBanWhiteList")
    
    
    return
}

func NewDeleteBanWhiteListResponse() (response *DeleteBanWhiteListResponse) {
    response = &DeleteBanWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBanWhiteList
// This API is used to delete the list of blocking allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBanWhiteList(request *DeleteBanWhiteListRequest) (response *DeleteBanWhiteListResponse, err error) {
    return c.DeleteBanWhiteListWithContext(context.Background(), request)
}

// DeleteBanWhiteList
// This API is used to delete the list of blocking allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBanWhiteListWithContext(ctx context.Context, request *DeleteBanWhiteListRequest) (response *DeleteBanWhiteListResponse, err error) {
    if request == nil {
        request = NewDeleteBanWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBanWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBanWhiteList require credential")
    }

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

func NewDeleteBaselinePolicyRequest() (request *DeleteBaselinePolicyRequest) {
    request = &DeleteBaselinePolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBaselinePolicy")
    
    
    return
}

func NewDeleteBaselinePolicyResponse() (response *DeleteBaselinePolicyResponse) {
    response = &DeleteBaselinePolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBaselinePolicy
// This API is used to delete the baseline policy configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBaselinePolicy(request *DeleteBaselinePolicyRequest) (response *DeleteBaselinePolicyResponse, err error) {
    return c.DeleteBaselinePolicyWithContext(context.Background(), request)
}

// DeleteBaselinePolicy
// This API is used to delete the baseline policy configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBaselinePolicyWithContext(ctx context.Context, request *DeleteBaselinePolicyRequest) (response *DeleteBaselinePolicyResponse, err error) {
    if request == nil {
        request = NewDeleteBaselinePolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBaselinePolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBaselinePolicy require credential")
    }

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

func NewDeleteBaselineStrategyRequest() (request *DeleteBaselineStrategyRequest) {
    request = &DeleteBaselineStrategyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBaselineStrategy")
    
    
    return
}

func NewDeleteBaselineStrategyResponse() (response *DeleteBaselineStrategyResponse) {
    response = &DeleteBaselineStrategyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBaselineStrategy
// This API is used to delete the policy by baseline policy ID.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteBaselineStrategy(request *DeleteBaselineStrategyRequest) (response *DeleteBaselineStrategyResponse, err error) {
    return c.DeleteBaselineStrategyWithContext(context.Background(), request)
}

// DeleteBaselineStrategy
// This API is used to delete the policy by baseline policy ID.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteBaselineStrategyWithContext(ctx context.Context, request *DeleteBaselineStrategyRequest) (response *DeleteBaselineStrategyResponse, err error) {
    if request == nil {
        request = NewDeleteBaselineStrategyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBaselineStrategy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBaselineStrategy require credential")
    }

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

func NewDeleteBashEventsRequest() (request *DeleteBashEventsRequest) {
    request = &DeleteBashEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBashEvents")
    
    
    return
}

func NewDeleteBashEventsResponse() (response *DeleteBashEventsResponse) {
    response = &DeleteBashEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBashEvents
// This API is used to delete high-risk command events based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashEvents(request *DeleteBashEventsRequest) (response *DeleteBashEventsResponse, err error) {
    return c.DeleteBashEventsWithContext(context.Background(), request)
}

// DeleteBashEvents
// This API is used to delete high-risk command events based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashEventsWithContext(ctx context.Context, request *DeleteBashEventsRequest) (response *DeleteBashEventsResponse, err error) {
    if request == nil {
        request = NewDeleteBashEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBashEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBashEvents require credential")
    }

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

func NewDeleteBashPoliciesRequest() (request *DeleteBashPoliciesRequest) {
    request = &DeleteBashPoliciesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBashPolicies")
    
    
    return
}

func NewDeleteBashPoliciesResponse() (response *DeleteBashPoliciesResponse) {
    response = &DeleteBashPoliciesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBashPolicies
// This API is used to delete high-risk command policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashPolicies(request *DeleteBashPoliciesRequest) (response *DeleteBashPoliciesResponse, err error) {
    return c.DeleteBashPoliciesWithContext(context.Background(), request)
}

// DeleteBashPolicies
// This API is used to delete high-risk command policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashPoliciesWithContext(ctx context.Context, request *DeleteBashPoliciesRequest) (response *DeleteBashPoliciesResponse, err error) {
    if request == nil {
        request = NewDeleteBashPoliciesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBashPolicies")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBashPolicies require credential")
    }

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

func NewDeleteBashRulesRequest() (request *DeleteBashRulesRequest) {
    request = &DeleteBashRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBashRules")
    
    
    return
}

func NewDeleteBashRulesResponse() (response *DeleteBashRulesResponse) {
    response = &DeleteBashRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBashRules
// This API is used to delete high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashRules(request *DeleteBashRulesRequest) (response *DeleteBashRulesResponse, err error) {
    return c.DeleteBashRulesWithContext(context.Background(), request)
}

// DeleteBashRules
// This API is used to delete high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteBashRulesWithContext(ctx context.Context, request *DeleteBashRulesRequest) (response *DeleteBashRulesResponse, err error) {
    if request == nil {
        request = NewDeleteBashRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBashRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBashRules require credential")
    }

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

func NewDeleteBruteAttacksRequest() (request *DeleteBruteAttacksRequest) {
    request = &DeleteBruteAttacksRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteBruteAttacks")
    
    
    return
}

func NewDeleteBruteAttacksResponse() (response *DeleteBruteAttacksResponse) {
    response = &DeleteBruteAttacksResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteBruteAttacks
// This API is used to delete brute force attack records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteBruteAttacks(request *DeleteBruteAttacksRequest) (response *DeleteBruteAttacksResponse, err error) {
    return c.DeleteBruteAttacksWithContext(context.Background(), request)
}

// DeleteBruteAttacks
// This API is used to delete brute force attack records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteBruteAttacksWithContext(ctx context.Context, request *DeleteBruteAttacksRequest) (response *DeleteBruteAttacksResponse, err error) {
    if request == nil {
        request = NewDeleteBruteAttacksRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteBruteAttacks")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteBruteAttacks require credential")
    }

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

func NewDeleteLicenseRecordRequest() (request *DeleteLicenseRecordRequest) {
    request = &DeleteLicenseRecordRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteLicenseRecord")
    
    
    return
}

func NewDeleteLicenseRecordResponse() (response *DeleteLicenseRecordResponse) {
    response = &DeleteLicenseRecordResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteLicenseRecord
// This API is used to delete expired orders in Authorization Management - Order List. (Deleted orders are not counted in statistics.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLicenseRecord(request *DeleteLicenseRecordRequest) (response *DeleteLicenseRecordResponse, err error) {
    return c.DeleteLicenseRecordWithContext(context.Background(), request)
}

// DeleteLicenseRecord
// This API is used to delete expired orders in Authorization Management - Order List. (Deleted orders are not counted in statistics.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLicenseRecordWithContext(ctx context.Context, request *DeleteLicenseRecordRequest) (response *DeleteLicenseRecordResponse, err error) {
    if request == nil {
        request = NewDeleteLicenseRecordRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteLicenseRecord")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteLicenseRecord require credential")
    }

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

func NewDeleteLicenseRecordAllRequest() (request *DeleteLicenseRecordAllRequest) {
    request = &DeleteLicenseRecordAllRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteLicenseRecordAll")
    
    
    return
}

func NewDeleteLicenseRecordAllResponse() (response *DeleteLicenseRecordAllResponse) {
    response = &DeleteLicenseRecordAllResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteLicenseRecordAll
// This API is used to delete all authorization records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLicenseRecordAll(request *DeleteLicenseRecordAllRequest) (response *DeleteLicenseRecordAllResponse, err error) {
    return c.DeleteLicenseRecordAllWithContext(context.Background(), request)
}

// DeleteLicenseRecordAll
// This API is used to delete all authorization records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLicenseRecordAllWithContext(ctx context.Context, request *DeleteLicenseRecordAllRequest) (response *DeleteLicenseRecordAllResponse, err error) {
    if request == nil {
        request = NewDeleteLicenseRecordAllRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteLicenseRecordAll")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteLicenseRecordAll require credential")
    }

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

func NewDeleteLogExportRequest() (request *DeleteLogExportRequest) {
    request = &DeleteLogExportRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteLogExport")
    
    
    return
}

func NewDeleteLogExportResponse() (response *DeleteLogExportResponse) {
    response = &DeleteLogExportResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteLogExport
// This API is used to delete log download tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLogExport(request *DeleteLogExportRequest) (response *DeleteLogExportResponse, err error) {
    return c.DeleteLogExportWithContext(context.Background(), request)
}

// DeleteLogExport
// This API is used to delete log download tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteLogExportWithContext(ctx context.Context, request *DeleteLogExportRequest) (response *DeleteLogExportResponse, err error) {
    if request == nil {
        request = NewDeleteLogExportRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteLogExport")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteLogExport require credential")
    }

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

func NewDeleteLoginWhiteListRequest() (request *DeleteLoginWhiteListRequest) {
    request = &DeleteLoginWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteLoginWhiteList")
    
    
    return
}

func NewDeleteLoginWhiteListResponse() (response *DeleteLoginWhiteListResponse) {
    response = &DeleteLoginWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteLoginWhiteList
// This API is used to delete the cross-region log-in allowlist rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteLoginWhiteList(request *DeleteLoginWhiteListRequest) (response *DeleteLoginWhiteListResponse, err error) {
    return c.DeleteLoginWhiteListWithContext(context.Background(), request)
}

// DeleteLoginWhiteList
// This API is used to delete the cross-region log-in allowlist rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteLoginWhiteListWithContext(ctx context.Context, request *DeleteLoginWhiteListRequest) (response *DeleteLoginWhiteListResponse, err error) {
    if request == nil {
        request = NewDeleteLoginWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteLoginWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteLoginWhiteList require credential")
    }

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

func NewDeleteMachineRequest() (request *DeleteMachineRequest) {
    request = &DeleteMachineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMachine")
    
    
    return
}

func NewDeleteMachineResponse() (response *DeleteMachineResponse) {
    response = &DeleteMachineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMachine
// This API is used to uninstall the CWPP client.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_MACHINEDELETE = "FailedOperation.MachineDelete"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachine(request *DeleteMachineRequest) (response *DeleteMachineResponse, err error) {
    return c.DeleteMachineWithContext(context.Background(), request)
}

// DeleteMachine
// This API is used to uninstall the CWPP client.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_MACHINEDELETE = "FailedOperation.MachineDelete"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachineWithContext(ctx context.Context, request *DeleteMachineRequest) (response *DeleteMachineResponse, err error) {
    if request == nil {
        request = NewDeleteMachineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMachine")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMachine require credential")
    }

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

func NewDeleteMachineClearHistoryRequest() (request *DeleteMachineClearHistoryRequest) {
    request = &DeleteMachineClearHistoryRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMachineClearHistory")
    
    
    return
}

func NewDeleteMachineClearHistoryResponse() (response *DeleteMachineClearHistoryResponse) {
    response = &DeleteMachineClearHistoryResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMachineClearHistory
// This API is used to delete clearing records of a machine.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_MACHINEDELETE = "FailedOperation.MachineDelete"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachineClearHistory(request *DeleteMachineClearHistoryRequest) (response *DeleteMachineClearHistoryResponse, err error) {
    return c.DeleteMachineClearHistoryWithContext(context.Background(), request)
}

// DeleteMachineClearHistory
// This API is used to delete clearing records of a machine.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_MACHINEDELETE = "FailedOperation.MachineDelete"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachineClearHistoryWithContext(ctx context.Context, request *DeleteMachineClearHistoryRequest) (response *DeleteMachineClearHistoryResponse, err error) {
    if request == nil {
        request = NewDeleteMachineClearHistoryRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMachineClearHistory")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMachineClearHistory require credential")
    }

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

func NewDeleteMachineTagRequest() (request *DeleteMachineTagRequest) {
    request = &DeleteMachineTagRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMachineTag")
    
    
    return
}

func NewDeleteMachineTagResponse() (response *DeleteMachineTagResponse) {
    response = &DeleteMachineTagResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMachineTag
// This API is used to delete tags associated with the server.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachineTag(request *DeleteMachineTagRequest) (response *DeleteMachineTagResponse, err error) {
    return c.DeleteMachineTagWithContext(context.Background(), request)
}

// DeleteMachineTag
// This API is used to delete tags associated with the server.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMachineTagWithContext(ctx context.Context, request *DeleteMachineTagRequest) (response *DeleteMachineTagResponse, err error) {
    if request == nil {
        request = NewDeleteMachineTagRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMachineTag")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMachineTag require credential")
    }

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

func NewDeleteMaliciousRequestWhiteListRequest() (request *DeleteMaliciousRequestWhiteListRequest) {
    request = &DeleteMaliciousRequestWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMaliciousRequestWhiteList")
    
    
    return
}

func NewDeleteMaliciousRequestWhiteListResponse() (response *DeleteMaliciousRequestWhiteListResponse) {
    response = &DeleteMaliciousRequestWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMaliciousRequestWhiteList
// This API is used to delete the malicious request allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMaliciousRequestWhiteList(request *DeleteMaliciousRequestWhiteListRequest) (response *DeleteMaliciousRequestWhiteListResponse, err error) {
    return c.DeleteMaliciousRequestWhiteListWithContext(context.Background(), request)
}

// DeleteMaliciousRequestWhiteList
// This API is used to delete the malicious request allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMaliciousRequestWhiteListWithContext(ctx context.Context, request *DeleteMaliciousRequestWhiteListRequest) (response *DeleteMaliciousRequestWhiteListResponse, err error) {
    if request == nil {
        request = NewDeleteMaliciousRequestWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMaliciousRequestWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMaliciousRequestWhiteList require credential")
    }

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

func NewDeleteMaliciousRequestsRequest() (request *DeleteMaliciousRequestsRequest) {
    request = &DeleteMaliciousRequestsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMaliciousRequests")
    
    
    return
}

func NewDeleteMaliciousRequestsResponse() (response *DeleteMaliciousRequestsResponse) {
    response = &DeleteMaliciousRequestsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMaliciousRequests
// This API is used to delete malicious request records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMaliciousRequests(request *DeleteMaliciousRequestsRequest) (response *DeleteMaliciousRequestsResponse, err error) {
    return c.DeleteMaliciousRequestsWithContext(context.Background(), request)
}

// DeleteMaliciousRequests
// This API is used to delete malicious request records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMaliciousRequestsWithContext(ctx context.Context, request *DeleteMaliciousRequestsRequest) (response *DeleteMaliciousRequestsResponse, err error) {
    if request == nil {
        request = NewDeleteMaliciousRequestsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMaliciousRequests")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMaliciousRequests require credential")
    }

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

func NewDeleteMalwareScanTaskRequest() (request *DeleteMalwareScanTaskRequest) {
    request = &DeleteMalwareScanTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMalwareScanTask")
    
    
    return
}

func NewDeleteMalwareScanTaskResponse() (response *DeleteMalwareScanTaskResponse) {
    response = &DeleteMalwareScanTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMalwareScanTask
// This API is used to terminate the scan tasks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMalwareScanTask(request *DeleteMalwareScanTaskRequest) (response *DeleteMalwareScanTaskResponse, err error) {
    return c.DeleteMalwareScanTaskWithContext(context.Background(), request)
}

// DeleteMalwareScanTask
// This API is used to terminate the scan tasks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeleteMalwareScanTaskWithContext(ctx context.Context, request *DeleteMalwareScanTaskRequest) (response *DeleteMalwareScanTaskResponse, err error) {
    if request == nil {
        request = NewDeleteMalwareScanTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMalwareScanTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMalwareScanTask require credential")
    }

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

func NewDeleteMalwareWhiteListRequest() (request *DeleteMalwareWhiteListRequest) {
    request = &DeleteMalwareWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMalwareWhiteList")
    
    
    return
}

func NewDeleteMalwareWhiteListResponse() (response *DeleteMalwareWhiteListResponse) {
    response = &DeleteMalwareWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMalwareWhiteList
// This API is used to delete the Trojan whitelist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMalwareWhiteList(request *DeleteMalwareWhiteListRequest) (response *DeleteMalwareWhiteListResponse, err error) {
    return c.DeleteMalwareWhiteListWithContext(context.Background(), request)
}

// DeleteMalwareWhiteList
// This API is used to delete the Trojan whitelist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMalwareWhiteListWithContext(ctx context.Context, request *DeleteMalwareWhiteListRequest) (response *DeleteMalwareWhiteListResponse, err error) {
    if request == nil {
        request = NewDeleteMalwareWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMalwareWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMalwareWhiteList require credential")
    }

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

func NewDeleteMalwaresRequest() (request *DeleteMalwaresRequest) {
    request = &DeleteMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteMalwares")
    
    
    return
}

func NewDeleteMalwaresResponse() (response *DeleteMalwaresResponse) {
    response = &DeleteMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteMalwares
// This API is used to delete Trojan records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMalwares(request *DeleteMalwaresRequest) (response *DeleteMalwaresResponse, err error) {
    return c.DeleteMalwaresWithContext(context.Background(), request)
}

// DeleteMalwares
// This API is used to delete Trojan records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteMalwaresWithContext(ctx context.Context, request *DeleteMalwaresRequest) (response *DeleteMalwaresResponse, err error) {
    if request == nil {
        request = NewDeleteMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteMalwares require credential")
    }

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

func NewDeleteNetAttackWhiteListRequest() (request *DeleteNetAttackWhiteListRequest) {
    request = &DeleteNetAttackWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteNetAttackWhiteList")
    
    
    return
}

func NewDeleteNetAttackWhiteListResponse() (response *DeleteNetAttackWhiteListResponse) {
    response = &DeleteNetAttackWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteNetAttackWhiteList
// This API is used to delete the network attack allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteNetAttackWhiteList(request *DeleteNetAttackWhiteListRequest) (response *DeleteNetAttackWhiteListResponse, err error) {
    return c.DeleteNetAttackWhiteListWithContext(context.Background(), request)
}

// DeleteNetAttackWhiteList
// This API is used to delete the network attack allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteNetAttackWhiteListWithContext(ctx context.Context, request *DeleteNetAttackWhiteListRequest) (response *DeleteNetAttackWhiteListResponse, err error) {
    if request == nil {
        request = NewDeleteNetAttackWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteNetAttackWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteNetAttackWhiteList require credential")
    }

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

func NewDeleteNonlocalLoginPlacesRequest() (request *DeleteNonlocalLoginPlacesRequest) {
    request = &DeleteNonlocalLoginPlacesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteNonlocalLoginPlaces")
    
    
    return
}

func NewDeleteNonlocalLoginPlacesResponse() (response *DeleteNonlocalLoginPlacesResponse) {
    response = &DeleteNonlocalLoginPlacesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteNonlocalLoginPlaces
// This API is used to delete cross-region log-in records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteNonlocalLoginPlaces(request *DeleteNonlocalLoginPlacesRequest) (response *DeleteNonlocalLoginPlacesResponse, err error) {
    return c.DeleteNonlocalLoginPlacesWithContext(context.Background(), request)
}

// DeleteNonlocalLoginPlaces
// This API is used to delete cross-region log-in records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteNonlocalLoginPlacesWithContext(ctx context.Context, request *DeleteNonlocalLoginPlacesRequest) (response *DeleteNonlocalLoginPlacesResponse, err error) {
    if request == nil {
        request = NewDeleteNonlocalLoginPlacesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteNonlocalLoginPlaces")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteNonlocalLoginPlaces require credential")
    }

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

func NewDeletePrivilegeEventsRequest() (request *DeletePrivilegeEventsRequest) {
    request = &DeletePrivilegeEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeletePrivilegeEvents")
    
    
    return
}

func NewDeletePrivilegeEventsResponse() (response *DeletePrivilegeEventsResponse) {
    response = &DeletePrivilegeEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeletePrivilegeEvents
// This API is used to delete local privilege escalation based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeletePrivilegeEvents(request *DeletePrivilegeEventsRequest) (response *DeletePrivilegeEventsResponse, err error) {
    return c.DeletePrivilegeEventsWithContext(context.Background(), request)
}

// DeletePrivilegeEvents
// This API is used to delete local privilege escalation based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DeletePrivilegeEventsWithContext(ctx context.Context, request *DeletePrivilegeEventsRequest) (response *DeletePrivilegeEventsResponse, err error) {
    if request == nil {
        request = NewDeletePrivilegeEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeletePrivilegeEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeletePrivilegeEvents require credential")
    }

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

func NewDeletePrivilegeRulesRequest() (request *DeletePrivilegeRulesRequest) {
    request = &DeletePrivilegeRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeletePrivilegeRules")
    
    
    return
}

func NewDeletePrivilegeRulesResponse() (response *DeletePrivilegeRulesResponse) {
    response = &DeletePrivilegeRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeletePrivilegeRules
// This API is used to delete local privilege elevation rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeletePrivilegeRules(request *DeletePrivilegeRulesRequest) (response *DeletePrivilegeRulesResponse, err error) {
    return c.DeletePrivilegeRulesWithContext(context.Background(), request)
}

// DeletePrivilegeRules
// This API is used to delete local privilege elevation rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeletePrivilegeRulesWithContext(ctx context.Context, request *DeletePrivilegeRulesRequest) (response *DeletePrivilegeRulesResponse, err error) {
    if request == nil {
        request = NewDeletePrivilegeRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeletePrivilegeRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeletePrivilegeRules require credential")
    }

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

func NewDeleteReverseShellEventsRequest() (request *DeleteReverseShellEventsRequest) {
    request = &DeleteReverseShellEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteReverseShellEvents")
    
    
    return
}

func NewDeleteReverseShellEventsResponse() (response *DeleteReverseShellEventsResponse) {
    response = &DeleteReverseShellEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteReverseShellEvents
// This API is used to delete Reverse Shell events based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteReverseShellEvents(request *DeleteReverseShellEventsRequest) (response *DeleteReverseShellEventsResponse, err error) {
    return c.DeleteReverseShellEventsWithContext(context.Background(), request)
}

// DeleteReverseShellEvents
// This API is used to delete Reverse Shell events based on IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteReverseShellEventsWithContext(ctx context.Context, request *DeleteReverseShellEventsRequest) (response *DeleteReverseShellEventsResponse, err error) {
    if request == nil {
        request = NewDeleteReverseShellEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteReverseShellEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteReverseShellEvents require credential")
    }

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

func NewDeleteReverseShellRulesRequest() (request *DeleteReverseShellRulesRequest) {
    request = &DeleteReverseShellRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteReverseShellRules")
    
    
    return
}

func NewDeleteReverseShellRulesResponse() (response *DeleteReverseShellRulesResponse) {
    response = &DeleteReverseShellRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteReverseShellRules
// This API is used to delete Reverse Shell rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_REVERSHELLKEYFIELDALLEMPTY = "InvalidParameter.ReverShellKeyFieldAllEmpty"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteReverseShellRules(request *DeleteReverseShellRulesRequest) (response *DeleteReverseShellRulesResponse, err error) {
    return c.DeleteReverseShellRulesWithContext(context.Background(), request)
}

// DeleteReverseShellRules
// This API is used to delete Reverse Shell rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_REVERSHELLKEYFIELDALLEMPTY = "InvalidParameter.ReverShellKeyFieldAllEmpty"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteReverseShellRulesWithContext(ctx context.Context, request *DeleteReverseShellRulesRequest) (response *DeleteReverseShellRulesResponse, err error) {
    if request == nil {
        request = NewDeleteReverseShellRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteReverseShellRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteReverseShellRules require credential")
    }

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

func NewDeleteRiskDnsEventRequest() (request *DeleteRiskDnsEventRequest) {
    request = &DeleteRiskDnsEventRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteRiskDnsEvent")
    
    
    return
}

func NewDeleteRiskDnsEventResponse() (response *DeleteRiskDnsEventResponse) {
    response = &DeleteRiskDnsEventResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteRiskDnsEvent
// This API is used to delete malicious request events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DeleteRiskDnsEvent(request *DeleteRiskDnsEventRequest) (response *DeleteRiskDnsEventResponse, err error) {
    return c.DeleteRiskDnsEventWithContext(context.Background(), request)
}

// DeleteRiskDnsEvent
// This API is used to delete malicious request events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DeleteRiskDnsEventWithContext(ctx context.Context, request *DeleteRiskDnsEventRequest) (response *DeleteRiskDnsEventResponse, err error) {
    if request == nil {
        request = NewDeleteRiskDnsEventRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteRiskDnsEvent")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteRiskDnsEvent require credential")
    }

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

func NewDeleteRiskDnsPolicyRequest() (request *DeleteRiskDnsPolicyRequest) {
    request = &DeleteRiskDnsPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteRiskDnsPolicy")
    
    
    return
}

func NewDeleteRiskDnsPolicyResponse() (response *DeleteRiskDnsPolicyResponse) {
    response = &DeleteRiskDnsPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteRiskDnsPolicy
// This API is used to delete malicious request policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DeleteRiskDnsPolicy(request *DeleteRiskDnsPolicyRequest) (response *DeleteRiskDnsPolicyResponse, err error) {
    return c.DeleteRiskDnsPolicyWithContext(context.Background(), request)
}

// DeleteRiskDnsPolicy
// This API is used to delete malicious request policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DeleteRiskDnsPolicyWithContext(ctx context.Context, request *DeleteRiskDnsPolicyRequest) (response *DeleteRiskDnsPolicyResponse, err error) {
    if request == nil {
        request = NewDeleteRiskDnsPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteRiskDnsPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteRiskDnsPolicy require credential")
    }

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

func NewDeleteScanTaskRequest() (request *DeleteScanTaskRequest) {
    request = &DeleteScanTaskRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteScanTask")
    
    
    return
}

func NewDeleteScanTaskResponse() (response *DeleteScanTaskResponse) {
    response = &DeleteScanTaskResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteScanTask
// This API is used to stop scan tasks of a specified type.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteScanTask(request *DeleteScanTaskRequest) (response *DeleteScanTaskResponse, err error) {
    return c.DeleteScanTaskWithContext(context.Background(), request)
}

// DeleteScanTask
// This API is used to stop scan tasks of a specified type.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteScanTaskWithContext(ctx context.Context, request *DeleteScanTaskRequest) (response *DeleteScanTaskResponse, err error) {
    if request == nil {
        request = NewDeleteScanTaskRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteScanTask")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteScanTask require credential")
    }

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

func NewDeleteSearchTemplateRequest() (request *DeleteSearchTemplateRequest) {
    request = &DeleteSearchTemplateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteSearchTemplate")
    
    
    return
}

func NewDeleteSearchTemplateResponse() (response *DeleteSearchTemplateResponse) {
    response = &DeleteSearchTemplateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteSearchTemplate
// This API is used to delete the retrieval template.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteSearchTemplate(request *DeleteSearchTemplateRequest) (response *DeleteSearchTemplateResponse, err error) {
    return c.DeleteSearchTemplateWithContext(context.Background(), request)
}

// DeleteSearchTemplate
// This API is used to delete the retrieval template.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteSearchTemplateWithContext(ctx context.Context, request *DeleteSearchTemplateRequest) (response *DeleteSearchTemplateResponse, err error) {
    if request == nil {
        request = NewDeleteSearchTemplateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteSearchTemplate")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteSearchTemplate require credential")
    }

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

func NewDeleteTagsRequest() (request *DeleteTagsRequest) {
    request = &DeleteTagsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteTags")
    
    
    return
}

func NewDeleteTagsResponse() (response *DeleteTagsResponse) {
    response = &DeleteTagsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteTags
// This API is used to delete tags.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteTags(request *DeleteTagsRequest) (response *DeleteTagsResponse, err error) {
    return c.DeleteTagsWithContext(context.Background(), request)
}

// DeleteTags
// This API is used to delete tags.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteTagsWithContext(ctx context.Context, request *DeleteTagsRequest) (response *DeleteTagsResponse, err error) {
    if request == nil {
        request = NewDeleteTagsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteTags")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteTags require credential")
    }

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

func NewDeleteWebHookPolicyRequest() (request *DeleteWebHookPolicyRequest) {
    request = &DeleteWebHookPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteWebHookPolicy")
    
    
    return
}

func NewDeleteWebHookPolicyResponse() (response *DeleteWebHookPolicyResponse) {
    response = &DeleteWebHookPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteWebHookPolicy
// This API is used to delete alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookPolicy(request *DeleteWebHookPolicyRequest) (response *DeleteWebHookPolicyResponse, err error) {
    return c.DeleteWebHookPolicyWithContext(context.Background(), request)
}

// DeleteWebHookPolicy
// This API is used to delete alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookPolicyWithContext(ctx context.Context, request *DeleteWebHookPolicyRequest) (response *DeleteWebHookPolicyResponse, err error) {
    if request == nil {
        request = NewDeleteWebHookPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteWebHookPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteWebHookPolicy require credential")
    }

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

func NewDeleteWebHookReceiverRequest() (request *DeleteWebHookReceiverRequest) {
    request = &DeleteWebHookReceiverRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteWebHookReceiver")
    
    
    return
}

func NewDeleteWebHookReceiverResponse() (response *DeleteWebHookReceiverResponse) {
    response = &DeleteWebHookReceiverResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteWebHookReceiver
// This API is used to delete the alert recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookReceiver(request *DeleteWebHookReceiverRequest) (response *DeleteWebHookReceiverResponse, err error) {
    return c.DeleteWebHookReceiverWithContext(context.Background(), request)
}

// DeleteWebHookReceiver
// This API is used to delete the alert recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookReceiverWithContext(ctx context.Context, request *DeleteWebHookReceiverRequest) (response *DeleteWebHookReceiverResponse, err error) {
    if request == nil {
        request = NewDeleteWebHookReceiverRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteWebHookReceiver")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteWebHookReceiver require credential")
    }

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

func NewDeleteWebHookRuleRequest() (request *DeleteWebHookRuleRequest) {
    request = &DeleteWebHookRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DeleteWebHookRule")
    
    
    return
}

func NewDeleteWebHookRuleResponse() (response *DeleteWebHookRuleResponse) {
    response = &DeleteWebHookRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DeleteWebHookRule
// This API is used to delete the rules of WeCom chatbots.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookRule(request *DeleteWebHookRuleRequest) (response *DeleteWebHookRuleResponse, err error) {
    return c.DeleteWebHookRuleWithContext(context.Background(), request)
}

// DeleteWebHookRule
// This API is used to delete the rules of WeCom chatbots.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DeleteWebHookRuleWithContext(ctx context.Context, request *DeleteWebHookRuleRequest) (response *DeleteWebHookRuleResponse, err error) {
    if request == nil {
        request = NewDeleteWebHookRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DeleteWebHookRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DeleteWebHookRule require credential")
    }

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

func NewDescribeABTestConfigRequest() (request *DescribeABTestConfigRequest) {
    request = &DescribeABTestConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeABTestConfig")
    
    
    return
}

func NewDescribeABTestConfigResponse() (response *DescribeABTestConfigResponse) {
    response = &DescribeABTestConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeABTestConfig
// This API is used to obtain the current grayscale configuration of the user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeABTestConfig(request *DescribeABTestConfigRequest) (response *DescribeABTestConfigResponse, err error) {
    return c.DescribeABTestConfigWithContext(context.Background(), request)
}

// DescribeABTestConfig
// This API is used to obtain the current grayscale configuration of the user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeABTestConfigWithContext(ctx context.Context, request *DescribeABTestConfigRequest) (response *DescribeABTestConfigResponse, err error) {
    if request == nil {
        request = NewDescribeABTestConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeABTestConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeABTestConfig require credential")
    }

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

func NewDescribeAESKeyRequest() (request *DescribeAESKeyRequest) {
    request = &DescribeAESKeyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAESKey")
    
    
    return
}

func NewDescribeAESKeyResponse() (response *DescribeAESKeyResponse) {
    response = &DescribeAESKeyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAESKey
// This API is used to obtain the configured aeskey and aesiv.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeAESKey(request *DescribeAESKeyRequest) (response *DescribeAESKeyResponse, err error) {
    return c.DescribeAESKeyWithContext(context.Background(), request)
}

// DescribeAESKey
// This API is used to obtain the configured aeskey and aesiv.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeAESKeyWithContext(ctx context.Context, request *DescribeAESKeyRequest) (response *DescribeAESKeyResponse, err error) {
    if request == nil {
        request = NewDescribeAESKeyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAESKey")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAESKey require credential")
    }

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

func NewDescribeAccountStatisticsRequest() (request *DescribeAccountStatisticsRequest) {
    request = &DescribeAccountStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAccountStatistics")
    
    
    return
}

func NewDescribeAccountStatisticsResponse() (response *DescribeAccountStatisticsResponse) {
    response = &DescribeAccountStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAccountStatistics
// This API is used to obtain the account statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAccountStatistics(request *DescribeAccountStatisticsRequest) (response *DescribeAccountStatisticsResponse, err error) {
    return c.DescribeAccountStatisticsWithContext(context.Background(), request)
}

// DescribeAccountStatistics
// This API is used to obtain the account statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAccountStatisticsWithContext(ctx context.Context, request *DescribeAccountStatisticsRequest) (response *DescribeAccountStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeAccountStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAccountStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAccountStatistics require credential")
    }

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

func NewDescribeAgentInstallCommandRequest() (request *DescribeAgentInstallCommandRequest) {
    request = &DescribeAgentInstallCommandRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAgentInstallCommand")
    
    
    return
}

func NewDescribeAgentInstallCommandResponse() (response *DescribeAgentInstallCommandResponse) {
    response = &DescribeAgentInstallCommandResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAgentInstallCommand
// This API is used to obtain the agent installation command.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeAgentInstallCommand(request *DescribeAgentInstallCommandRequest) (response *DescribeAgentInstallCommandResponse, err error) {
    return c.DescribeAgentInstallCommandWithContext(context.Background(), request)
}

// DescribeAgentInstallCommand
// This API is used to obtain the agent installation command.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeAgentInstallCommandWithContext(ctx context.Context, request *DescribeAgentInstallCommandRequest) (response *DescribeAgentInstallCommandResponse, err error) {
    if request == nil {
        request = NewDescribeAgentInstallCommandRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAgentInstallCommand")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAgentInstallCommand require credential")
    }

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

func NewDescribeAgentInstallationTokenRequest() (request *DescribeAgentInstallationTokenRequest) {
    request = &DescribeAgentInstallationTokenRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAgentInstallationToken")
    
    
    return
}

func NewDescribeAgentInstallationTokenResponse() (response *DescribeAgentInstallationTokenResponse) {
    response = &DescribeAgentInstallationTokenResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAgentInstallationToken
// This API is used to obtain the token for installing the agent in a hybrid cloud environment.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAgentInstallationToken(request *DescribeAgentInstallationTokenRequest) (response *DescribeAgentInstallationTokenResponse, err error) {
    return c.DescribeAgentInstallationTokenWithContext(context.Background(), request)
}

// DescribeAgentInstallationToken
// This API is used to obtain the token for installing the agent in a hybrid cloud environment.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAgentInstallationTokenWithContext(ctx context.Context, request *DescribeAgentInstallationTokenRequest) (response *DescribeAgentInstallationTokenResponse, err error) {
    if request == nil {
        request = NewDescribeAgentInstallationTokenRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAgentInstallationToken")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAgentInstallationToken require credential")
    }

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

func NewDescribeAlarmIncidentNodesRequest() (request *DescribeAlarmIncidentNodesRequest) {
    request = &DescribeAlarmIncidentNodesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAlarmIncidentNodes")
    
    
    return
}

func NewDescribeAlarmIncidentNodesResponse() (response *DescribeAlarmIncidentNodesResponse) {
    response = &DescribeAlarmIncidentNodesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAlarmIncidentNodes
// This API is used to obtain all node information on the event corresponding to an alarm.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAlarmIncidentNodes(request *DescribeAlarmIncidentNodesRequest) (response *DescribeAlarmIncidentNodesResponse, err error) {
    return c.DescribeAlarmIncidentNodesWithContext(context.Background(), request)
}

// DescribeAlarmIncidentNodes
// This API is used to obtain all node information on the event corresponding to an alarm.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAlarmIncidentNodesWithContext(ctx context.Context, request *DescribeAlarmIncidentNodesRequest) (response *DescribeAlarmIncidentNodesResponse, err error) {
    if request == nil {
        request = NewDescribeAlarmIncidentNodesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAlarmIncidentNodes")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAlarmIncidentNodes require credential")
    }

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

func NewDescribeAlarmVertexIdRequest() (request *DescribeAlarmVertexIdRequest) {
    request = &DescribeAlarmVertexIdRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAlarmVertexId")
    
    
    return
}

func NewDescribeAlarmVertexIdResponse() (response *DescribeAlarmVertexIdResponse) {
    response = &DescribeAlarmVertexIdResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAlarmVertexId
// This API is used to query the list of alarm IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAlarmVertexId(request *DescribeAlarmVertexIdRequest) (response *DescribeAlarmVertexIdResponse, err error) {
    return c.DescribeAlarmVertexIdWithContext(context.Background(), request)
}

// DescribeAlarmVertexId
// This API is used to query the list of alarm IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAlarmVertexIdWithContext(ctx context.Context, request *DescribeAlarmVertexIdRequest) (response *DescribeAlarmVertexIdResponse, err error) {
    if request == nil {
        request = NewDescribeAlarmVertexIdRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAlarmVertexId")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAlarmVertexId require credential")
    }

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

func NewDescribeAssetAppCountRequest() (request *DescribeAssetAppCountRequest) {
    request = &DescribeAssetAppCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetAppCount")
    
    
    return
}

func NewDescribeAssetAppCountResponse() (response *DescribeAssetAppCountResponse) {
    response = &DescribeAssetAppCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetAppCount
// This API is used to obtain the number of all software applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetAppCount(request *DescribeAssetAppCountRequest) (response *DescribeAssetAppCountResponse, err error) {
    return c.DescribeAssetAppCountWithContext(context.Background(), request)
}

// DescribeAssetAppCount
// This API is used to obtain the number of all software applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetAppCountWithContext(ctx context.Context, request *DescribeAssetAppCountRequest) (response *DescribeAssetAppCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetAppCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetAppCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetAppCount require credential")
    }

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

func NewDescribeAssetAppListRequest() (request *DescribeAssetAppListRequest) {
    request = &DescribeAssetAppListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetAppList")
    
    
    return
}

func NewDescribeAssetAppListResponse() (response *DescribeAssetAppListResponse) {
    response = &DescribeAssetAppListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetAppList
// This API is used to query the application list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetAppList(request *DescribeAssetAppListRequest) (response *DescribeAssetAppListResponse, err error) {
    return c.DescribeAssetAppListWithContext(context.Background(), request)
}

// DescribeAssetAppList
// This API is used to query the application list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetAppListWithContext(ctx context.Context, request *DescribeAssetAppListRequest) (response *DescribeAssetAppListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetAppListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetAppList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetAppList require credential")
    }

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

func NewDescribeAssetAppProcessListRequest() (request *DescribeAssetAppProcessListRequest) {
    request = &DescribeAssetAppProcessListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetAppProcessList")
    
    
    return
}

func NewDescribeAssetAppProcessListResponse() (response *DescribeAssetAppProcessListResponse) {
    response = &DescribeAssetAppProcessListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetAppProcessList
// This API is used to obtain the list of software's associated processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetAppProcessList(request *DescribeAssetAppProcessListRequest) (response *DescribeAssetAppProcessListResponse, err error) {
    return c.DescribeAssetAppProcessListWithContext(context.Background(), request)
}

// DescribeAssetAppProcessList
// This API is used to obtain the list of software's associated processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetAppProcessListWithContext(ctx context.Context, request *DescribeAssetAppProcessListRequest) (response *DescribeAssetAppProcessListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetAppProcessListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetAppProcessList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetAppProcessList require credential")
    }

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

func NewDescribeAssetCoreModuleInfoRequest() (request *DescribeAssetCoreModuleInfoRequest) {
    request = &DescribeAssetCoreModuleInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetCoreModuleInfo")
    
    
    return
}

func NewDescribeAssetCoreModuleInfoResponse() (response *DescribeAssetCoreModuleInfoResponse) {
    response = &DescribeAssetCoreModuleInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetCoreModuleInfo
// This API is used to obtain the kernel module details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetCoreModuleInfo(request *DescribeAssetCoreModuleInfoRequest) (response *DescribeAssetCoreModuleInfoResponse, err error) {
    return c.DescribeAssetCoreModuleInfoWithContext(context.Background(), request)
}

// DescribeAssetCoreModuleInfo
// This API is used to obtain the kernel module details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetCoreModuleInfoWithContext(ctx context.Context, request *DescribeAssetCoreModuleInfoRequest) (response *DescribeAssetCoreModuleInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetCoreModuleInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetCoreModuleInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetCoreModuleInfo require credential")
    }

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

func NewDescribeAssetCoreModuleListRequest() (request *DescribeAssetCoreModuleListRequest) {
    request = &DescribeAssetCoreModuleListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetCoreModuleList")
    
    
    return
}

func NewDescribeAssetCoreModuleListResponse() (response *DescribeAssetCoreModuleListResponse) {
    response = &DescribeAssetCoreModuleListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetCoreModuleList
// This API is used to query the list of asset management kernel modules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetCoreModuleList(request *DescribeAssetCoreModuleListRequest) (response *DescribeAssetCoreModuleListResponse, err error) {
    return c.DescribeAssetCoreModuleListWithContext(context.Background(), request)
}

// DescribeAssetCoreModuleList
// This API is used to query the list of asset management kernel modules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetCoreModuleListWithContext(ctx context.Context, request *DescribeAssetCoreModuleListRequest) (response *DescribeAssetCoreModuleListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetCoreModuleListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetCoreModuleList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetCoreModuleList require credential")
    }

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

func NewDescribeAssetDatabaseCountRequest() (request *DescribeAssetDatabaseCountRequest) {
    request = &DescribeAssetDatabaseCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetDatabaseCount")
    
    
    return
}

func NewDescribeAssetDatabaseCountResponse() (response *DescribeAssetDatabaseCountResponse) {
    response = &DescribeAssetDatabaseCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetDatabaseCount
// This API is used to obtain the number of all databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetDatabaseCount(request *DescribeAssetDatabaseCountRequest) (response *DescribeAssetDatabaseCountResponse, err error) {
    return c.DescribeAssetDatabaseCountWithContext(context.Background(), request)
}

// DescribeAssetDatabaseCount
// This API is used to obtain the number of all databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetDatabaseCountWithContext(ctx context.Context, request *DescribeAssetDatabaseCountRequest) (response *DescribeAssetDatabaseCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetDatabaseCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetDatabaseCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetDatabaseCount require credential")
    }

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

func NewDescribeAssetDatabaseInfoRequest() (request *DescribeAssetDatabaseInfoRequest) {
    request = &DescribeAssetDatabaseInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetDatabaseInfo")
    
    
    return
}

func NewDescribeAssetDatabaseInfoResponse() (response *DescribeAssetDatabaseInfoResponse) {
    response = &DescribeAssetDatabaseInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetDatabaseInfo
// This API is used to obtain the asset management database details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetDatabaseInfo(request *DescribeAssetDatabaseInfoRequest) (response *DescribeAssetDatabaseInfoResponse, err error) {
    return c.DescribeAssetDatabaseInfoWithContext(context.Background(), request)
}

// DescribeAssetDatabaseInfo
// This API is used to obtain the asset management database details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetDatabaseInfoWithContext(ctx context.Context, request *DescribeAssetDatabaseInfoRequest) (response *DescribeAssetDatabaseInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetDatabaseInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetDatabaseInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetDatabaseInfo require credential")
    }

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

func NewDescribeAssetDatabaseListRequest() (request *DescribeAssetDatabaseListRequest) {
    request = &DescribeAssetDatabaseListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetDatabaseList")
    
    
    return
}

func NewDescribeAssetDatabaseListResponse() (response *DescribeAssetDatabaseListResponse) {
    response = &DescribeAssetDatabaseListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetDatabaseList
// This API is used to query the list of asset management databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetDatabaseList(request *DescribeAssetDatabaseListRequest) (response *DescribeAssetDatabaseListResponse, err error) {
    return c.DescribeAssetDatabaseListWithContext(context.Background(), request)
}

// DescribeAssetDatabaseList
// This API is used to query the list of asset management databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetDatabaseListWithContext(ctx context.Context, request *DescribeAssetDatabaseListRequest) (response *DescribeAssetDatabaseListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetDatabaseListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetDatabaseList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetDatabaseList require credential")
    }

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

func NewDescribeAssetDiskListRequest() (request *DescribeAssetDiskListRequest) {
    request = &DescribeAssetDiskListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetDiskList")
    
    
    return
}

func NewDescribeAssetDiskListResponse() (response *DescribeAssetDiskListResponse) {
    response = &DescribeAssetDiskListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetDiskList
// This API is used to obtain the host disk partition list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetDiskList(request *DescribeAssetDiskListRequest) (response *DescribeAssetDiskListResponse, err error) {
    return c.DescribeAssetDiskListWithContext(context.Background(), request)
}

// DescribeAssetDiskList
// This API is used to obtain the host disk partition list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetDiskListWithContext(ctx context.Context, request *DescribeAssetDiskListRequest) (response *DescribeAssetDiskListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetDiskListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetDiskList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetDiskList require credential")
    }

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

func NewDescribeAssetEnvListRequest() (request *DescribeAssetEnvListRequest) {
    request = &DescribeAssetEnvListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetEnvList")
    
    
    return
}

func NewDescribeAssetEnvListResponse() (response *DescribeAssetEnvListResponse) {
    response = &DescribeAssetEnvListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetEnvList
// This API is used to query the list of asset management environment variables.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetEnvList(request *DescribeAssetEnvListRequest) (response *DescribeAssetEnvListResponse, err error) {
    return c.DescribeAssetEnvListWithContext(context.Background(), request)
}

// DescribeAssetEnvList
// This API is used to query the list of asset management environment variables.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetEnvListWithContext(ctx context.Context, request *DescribeAssetEnvListRequest) (response *DescribeAssetEnvListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetEnvListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetEnvList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetEnvList require credential")
    }

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

func NewDescribeAssetHostTotalCountRequest() (request *DescribeAssetHostTotalCountRequest) {
    request = &DescribeAssetHostTotalCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetHostTotalCount")
    
    
    return
}

func NewDescribeAssetHostTotalCountResponse() (response *DescribeAssetHostTotalCountResponse) {
    response = &DescribeAssetHostTotalCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetHostTotalCount
// This API is used to obtain the total number of resources of the host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetHostTotalCount(request *DescribeAssetHostTotalCountRequest) (response *DescribeAssetHostTotalCountResponse, err error) {
    return c.DescribeAssetHostTotalCountWithContext(context.Background(), request)
}

// DescribeAssetHostTotalCount
// This API is used to obtain the total number of resources of the host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetHostTotalCountWithContext(ctx context.Context, request *DescribeAssetHostTotalCountRequest) (response *DescribeAssetHostTotalCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetHostTotalCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetHostTotalCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetHostTotalCount require credential")
    }

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

func NewDescribeAssetInfoRequest() (request *DescribeAssetInfoRequest) {
    request = &DescribeAssetInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetInfo")
    
    
    return
}

func NewDescribeAssetInfoResponse() (response *DescribeAssetInfoResponse) {
    response = &DescribeAssetInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetInfo
// This API is used to obtain the number of assets, including hosts, accounts, ports, processes, software, databases, web applications, web frameworks, web services, and web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetInfo(request *DescribeAssetInfoRequest) (response *DescribeAssetInfoResponse, err error) {
    return c.DescribeAssetInfoWithContext(context.Background(), request)
}

// DescribeAssetInfo
// This API is used to obtain the number of assets, including hosts, accounts, ports, processes, software, databases, web applications, web frameworks, web services, and web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetInfoWithContext(ctx context.Context, request *DescribeAssetInfoRequest) (response *DescribeAssetInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetInfo require credential")
    }

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

func NewDescribeAssetInitServiceListRequest() (request *DescribeAssetInitServiceListRequest) {
    request = &DescribeAssetInitServiceListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetInitServiceList")
    
    
    return
}

func NewDescribeAssetInitServiceListResponse() (response *DescribeAssetInitServiceListResponse) {
    response = &DescribeAssetInitServiceListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetInitServiceList
// This API is used to query the list of asset management start services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetInitServiceList(request *DescribeAssetInitServiceListRequest) (response *DescribeAssetInitServiceListResponse, err error) {
    return c.DescribeAssetInitServiceListWithContext(context.Background(), request)
}

// DescribeAssetInitServiceList
// This API is used to query the list of asset management start services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetInitServiceListWithContext(ctx context.Context, request *DescribeAssetInitServiceListRequest) (response *DescribeAssetInitServiceListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetInitServiceListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetInitServiceList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetInitServiceList require credential")
    }

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

func NewDescribeAssetJarInfoRequest() (request *DescribeAssetJarInfoRequest) {
    request = &DescribeAssetJarInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetJarInfo")
    
    
    return
}

func NewDescribeAssetJarInfoResponse() (response *DescribeAssetJarInfoResponse) {
    response = &DescribeAssetJarInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetJarInfo
// This API is used to obtain Jar package details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetJarInfo(request *DescribeAssetJarInfoRequest) (response *DescribeAssetJarInfoResponse, err error) {
    return c.DescribeAssetJarInfoWithContext(context.Background(), request)
}

// DescribeAssetJarInfo
// This API is used to obtain Jar package details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetJarInfoWithContext(ctx context.Context, request *DescribeAssetJarInfoRequest) (response *DescribeAssetJarInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetJarInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetJarInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetJarInfo require credential")
    }

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

func NewDescribeAssetJarListRequest() (request *DescribeAssetJarListRequest) {
    request = &DescribeAssetJarListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetJarList")
    
    
    return
}

func NewDescribeAssetJarListResponse() (response *DescribeAssetJarListResponse) {
    response = &DescribeAssetJarListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetJarList
// This API is used to query the list of Jar packages.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetJarList(request *DescribeAssetJarListRequest) (response *DescribeAssetJarListResponse, err error) {
    return c.DescribeAssetJarListWithContext(context.Background(), request)
}

// DescribeAssetJarList
// This API is used to query the list of Jar packages.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetJarListWithContext(ctx context.Context, request *DescribeAssetJarListRequest) (response *DescribeAssetJarListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetJarListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetJarList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetJarList require credential")
    }

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

func NewDescribeAssetLoadInfoRequest() (request *DescribeAssetLoadInfoRequest) {
    request = &DescribeAssetLoadInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetLoadInfo")
    
    
    return
}

func NewDescribeAssetLoadInfoResponse() (response *DescribeAssetLoadInfoResponse) {
    response = &DescribeAssetLoadInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetLoadInfo
// This API is used to obtain the utilization of the system load, memory, and hard disk.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetLoadInfo(request *DescribeAssetLoadInfoRequest) (response *DescribeAssetLoadInfoResponse, err error) {
    return c.DescribeAssetLoadInfoWithContext(context.Background(), request)
}

// DescribeAssetLoadInfo
// This API is used to obtain the utilization of the system load, memory, and hard disk.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetLoadInfoWithContext(ctx context.Context, request *DescribeAssetLoadInfoRequest) (response *DescribeAssetLoadInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetLoadInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetLoadInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetLoadInfo require credential")
    }

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

func NewDescribeAssetMachineDetailRequest() (request *DescribeAssetMachineDetailRequest) {
    request = &DescribeAssetMachineDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetMachineDetail")
    
    
    return
}

func NewDescribeAssetMachineDetailResponse() (response *DescribeAssetMachineDetailResponse) {
    response = &DescribeAssetMachineDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetMachineDetail
// This API is used to obtain asset management host resource details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineDetail(request *DescribeAssetMachineDetailRequest) (response *DescribeAssetMachineDetailResponse, err error) {
    return c.DescribeAssetMachineDetailWithContext(context.Background(), request)
}

// DescribeAssetMachineDetail
// This API is used to obtain asset management host resource details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineDetailWithContext(ctx context.Context, request *DescribeAssetMachineDetailRequest) (response *DescribeAssetMachineDetailResponse, err error) {
    if request == nil {
        request = NewDescribeAssetMachineDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetMachineDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetMachineDetail require credential")
    }

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

func NewDescribeAssetMachineListRequest() (request *DescribeAssetMachineListRequest) {
    request = &DescribeAssetMachineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetMachineList")
    
    
    return
}

func NewDescribeAssetMachineListResponse() (response *DescribeAssetMachineListResponse) {
    response = &DescribeAssetMachineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetMachineList
// This API is used to obtain the resource monitoring list of the asset fingerprint page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineList(request *DescribeAssetMachineListRequest) (response *DescribeAssetMachineListResponse, err error) {
    return c.DescribeAssetMachineListWithContext(context.Background(), request)
}

// DescribeAssetMachineList
// This API is used to obtain the resource monitoring list of the asset fingerprint page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineListWithContext(ctx context.Context, request *DescribeAssetMachineListRequest) (response *DescribeAssetMachineListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetMachineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetMachineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetMachineList require credential")
    }

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

func NewDescribeAssetMachineTagTopRequest() (request *DescribeAssetMachineTagTopRequest) {
    request = &DescribeAssetMachineTagTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetMachineTagTop")
    
    
    return
}

func NewDescribeAssetMachineTagTopResponse() (response *DescribeAssetMachineTagTopResponse) {
    response = &DescribeAssetMachineTagTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetMachineTagTop
// This API is used to obtain top 5 host tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineTagTop(request *DescribeAssetMachineTagTopRequest) (response *DescribeAssetMachineTagTopResponse, err error) {
    return c.DescribeAssetMachineTagTopWithContext(context.Background(), request)
}

// DescribeAssetMachineTagTop
// This API is used to obtain top 5 host tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetMachineTagTopWithContext(ctx context.Context, request *DescribeAssetMachineTagTopRequest) (response *DescribeAssetMachineTagTopResponse, err error) {
    if request == nil {
        request = NewDescribeAssetMachineTagTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetMachineTagTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetMachineTagTop require credential")
    }

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

func NewDescribeAssetPlanTaskListRequest() (request *DescribeAssetPlanTaskListRequest) {
    request = &DescribeAssetPlanTaskListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetPlanTaskList")
    
    
    return
}

func NewDescribeAssetPlanTaskListResponse() (response *DescribeAssetPlanTaskListResponse) {
    response = &DescribeAssetPlanTaskListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetPlanTaskList
// This API is used to query the list of asset management plan tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetPlanTaskList(request *DescribeAssetPlanTaskListRequest) (response *DescribeAssetPlanTaskListResponse, err error) {
    return c.DescribeAssetPlanTaskListWithContext(context.Background(), request)
}

// DescribeAssetPlanTaskList
// This API is used to query the list of asset management plan tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetPlanTaskListWithContext(ctx context.Context, request *DescribeAssetPlanTaskListRequest) (response *DescribeAssetPlanTaskListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetPlanTaskListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetPlanTaskList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetPlanTaskList require credential")
    }

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

func NewDescribeAssetPortCountRequest() (request *DescribeAssetPortCountRequest) {
    request = &DescribeAssetPortCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetPortCount")
    
    
    return
}

func NewDescribeAssetPortCountResponse() (response *DescribeAssetPortCountResponse) {
    response = &DescribeAssetPortCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetPortCount
// This API is used to obtain the total number of ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetPortCount(request *DescribeAssetPortCountRequest) (response *DescribeAssetPortCountResponse, err error) {
    return c.DescribeAssetPortCountWithContext(context.Background(), request)
}

// DescribeAssetPortCount
// This API is used to obtain the total number of ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetPortCountWithContext(ctx context.Context, request *DescribeAssetPortCountRequest) (response *DescribeAssetPortCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetPortCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetPortCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetPortCount require credential")
    }

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

func NewDescribeAssetPortInfoListRequest() (request *DescribeAssetPortInfoListRequest) {
    request = &DescribeAssetPortInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetPortInfoList")
    
    
    return
}

func NewDescribeAssetPortInfoListResponse() (response *DescribeAssetPortInfoListResponse) {
    response = &DescribeAssetPortInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetPortInfoList
// This API is used to obtain the list of asset management ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetPortInfoList(request *DescribeAssetPortInfoListRequest) (response *DescribeAssetPortInfoListResponse, err error) {
    return c.DescribeAssetPortInfoListWithContext(context.Background(), request)
}

// DescribeAssetPortInfoList
// This API is used to obtain the list of asset management ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetPortInfoListWithContext(ctx context.Context, request *DescribeAssetPortInfoListRequest) (response *DescribeAssetPortInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetPortInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetPortInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetPortInfoList require credential")
    }

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

func NewDescribeAssetProcessCountRequest() (request *DescribeAssetProcessCountRequest) {
    request = &DescribeAssetProcessCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetProcessCount")
    
    
    return
}

func NewDescribeAssetProcessCountResponse() (response *DescribeAssetProcessCountResponse) {
    response = &DescribeAssetProcessCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetProcessCount
// This API is used to obtain the total number of processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetProcessCount(request *DescribeAssetProcessCountRequest) (response *DescribeAssetProcessCountResponse, err error) {
    return c.DescribeAssetProcessCountWithContext(context.Background(), request)
}

// DescribeAssetProcessCount
// This API is used to obtain the total number of processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetProcessCountWithContext(ctx context.Context, request *DescribeAssetProcessCountRequest) (response *DescribeAssetProcessCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetProcessCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetProcessCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetProcessCount require credential")
    }

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

func NewDescribeAssetProcessInfoListRequest() (request *DescribeAssetProcessInfoListRequest) {
    request = &DescribeAssetProcessInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetProcessInfoList")
    
    
    return
}

func NewDescribeAssetProcessInfoListResponse() (response *DescribeAssetProcessInfoListResponse) {
    response = &DescribeAssetProcessInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetProcessInfoList
// This API is used to obtain the list of asset management processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetProcessInfoList(request *DescribeAssetProcessInfoListRequest) (response *DescribeAssetProcessInfoListResponse, err error) {
    return c.DescribeAssetProcessInfoListWithContext(context.Background(), request)
}

// DescribeAssetProcessInfoList
// This API is used to obtain the list of asset management processes.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetProcessInfoListWithContext(ctx context.Context, request *DescribeAssetProcessInfoListRequest) (response *DescribeAssetProcessInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetProcessInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetProcessInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetProcessInfoList require credential")
    }

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

func NewDescribeAssetRecentMachineInfoRequest() (request *DescribeAssetRecentMachineInfoRequest) {
    request = &DescribeAssetRecentMachineInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetRecentMachineInfo")
    
    
    return
}

func NewDescribeAssetRecentMachineInfoResponse() (response *DescribeAssetRecentMachineInfoResponse) {
    response = &DescribeAssetRecentMachineInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetRecentMachineInfo
// This API is used to obtain the latest trend of hosts.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeAssetRecentMachineInfo(request *DescribeAssetRecentMachineInfoRequest) (response *DescribeAssetRecentMachineInfoResponse, err error) {
    return c.DescribeAssetRecentMachineInfoWithContext(context.Background(), request)
}

// DescribeAssetRecentMachineInfo
// This API is used to obtain the latest trend of hosts.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeAssetRecentMachineInfoWithContext(ctx context.Context, request *DescribeAssetRecentMachineInfoRequest) (response *DescribeAssetRecentMachineInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetRecentMachineInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetRecentMachineInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetRecentMachineInfo require credential")
    }

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

func NewDescribeAssetSystemPackageListRequest() (request *DescribeAssetSystemPackageListRequest) {
    request = &DescribeAssetSystemPackageListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetSystemPackageList")
    
    
    return
}

func NewDescribeAssetSystemPackageListResponse() (response *DescribeAssetSystemPackageListResponse) {
    response = &DescribeAssetSystemPackageListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetSystemPackageList
// This API is used to obtain the list of system installation packages for asset management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetSystemPackageList(request *DescribeAssetSystemPackageListRequest) (response *DescribeAssetSystemPackageListResponse, err error) {
    return c.DescribeAssetSystemPackageListWithContext(context.Background(), request)
}

// DescribeAssetSystemPackageList
// This API is used to obtain the list of system installation packages for asset management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetSystemPackageListWithContext(ctx context.Context, request *DescribeAssetSystemPackageListRequest) (response *DescribeAssetSystemPackageListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetSystemPackageListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetSystemPackageList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetSystemPackageList require credential")
    }

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

func NewDescribeAssetTotalCountRequest() (request *DescribeAssetTotalCountRequest) {
    request = &DescribeAssetTotalCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetTotalCount")
    
    
    return
}

func NewDescribeAssetTotalCountResponse() (response *DescribeAssetTotalCountResponse) {
    response = &DescribeAssetTotalCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetTotalCount
// This API is used to obtain the number of resources, including hosts, accounts, ports, processes, software, databases, web applications, web frameworks, web services, and web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetTotalCount(request *DescribeAssetTotalCountRequest) (response *DescribeAssetTotalCountResponse, err error) {
    return c.DescribeAssetTotalCountWithContext(context.Background(), request)
}

// DescribeAssetTotalCount
// This API is used to obtain the number of resources, including hosts, accounts, ports, processes, software, databases, web applications, web frameworks, web services, and web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetTotalCountWithContext(ctx context.Context, request *DescribeAssetTotalCountRequest) (response *DescribeAssetTotalCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetTotalCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetTotalCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetTotalCount require credential")
    }

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

func NewDescribeAssetTypeTopRequest() (request *DescribeAssetTypeTopRequest) {
    request = &DescribeAssetTypeTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetTypeTop")
    
    
    return
}

func NewDescribeAssetTypeTopResponse() (response *DescribeAssetTypeTopResponse) {
    response = &DescribeAssetTypeTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetTypeTop
// This API is used to obtain Top5 resources of various types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetTypeTop(request *DescribeAssetTypeTopRequest) (response *DescribeAssetTypeTopResponse, err error) {
    return c.DescribeAssetTypeTopWithContext(context.Background(), request)
}

// DescribeAssetTypeTop
// This API is used to obtain Top5 resources of various types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetTypeTopWithContext(ctx context.Context, request *DescribeAssetTypeTopRequest) (response *DescribeAssetTypeTopResponse, err error) {
    if request == nil {
        request = NewDescribeAssetTypeTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetTypeTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetTypeTop require credential")
    }

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

func NewDescribeAssetTypesRequest() (request *DescribeAssetTypesRequest) {
    request = &DescribeAssetTypesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetTypes")
    
    
    return
}

func NewDescribeAssetTypesResponse() (response *DescribeAssetTypesResponse) {
    response = &DescribeAssetTypesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetTypes
// This API is used to obtain the asset fingerprint type list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeAssetTypes(request *DescribeAssetTypesRequest) (response *DescribeAssetTypesResponse, err error) {
    return c.DescribeAssetTypesWithContext(context.Background(), request)
}

// DescribeAssetTypes
// This API is used to obtain the asset fingerprint type list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeAssetTypesWithContext(ctx context.Context, request *DescribeAssetTypesRequest) (response *DescribeAssetTypesResponse, err error) {
    if request == nil {
        request = NewDescribeAssetTypesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetTypes")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetTypes require credential")
    }

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

func NewDescribeAssetUserCountRequest() (request *DescribeAssetUserCountRequest) {
    request = &DescribeAssetUserCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetUserCount")
    
    
    return
}

func NewDescribeAssetUserCountResponse() (response *DescribeAssetUserCountResponse) {
    response = &DescribeAssetUserCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetUserCount
// This API is used to obtain the total number of accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetUserCount(request *DescribeAssetUserCountRequest) (response *DescribeAssetUserCountResponse, err error) {
    return c.DescribeAssetUserCountWithContext(context.Background(), request)
}

// DescribeAssetUserCount
// This API is used to obtain the total number of accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetUserCountWithContext(ctx context.Context, request *DescribeAssetUserCountRequest) (response *DescribeAssetUserCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetUserCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetUserCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetUserCount require credential")
    }

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

func NewDescribeAssetUserInfoRequest() (request *DescribeAssetUserInfoRequest) {
    request = &DescribeAssetUserInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetUserInfo")
    
    
    return
}

func NewDescribeAssetUserInfoResponse() (response *DescribeAssetUserInfoResponse) {
    response = &DescribeAssetUserInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetUserInfo
// This API is used to obtain host account details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) DescribeAssetUserInfo(request *DescribeAssetUserInfoRequest) (response *DescribeAssetUserInfoResponse, err error) {
    return c.DescribeAssetUserInfoWithContext(context.Background(), request)
}

// DescribeAssetUserInfo
// This API is used to obtain host account details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) DescribeAssetUserInfoWithContext(ctx context.Context, request *DescribeAssetUserInfoRequest) (response *DescribeAssetUserInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetUserInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetUserInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetUserInfo require credential")
    }

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

func NewDescribeAssetUserKeyListRequest() (request *DescribeAssetUserKeyListRequest) {
    request = &DescribeAssetUserKeyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetUserKeyList")
    
    
    return
}

func NewDescribeAssetUserKeyListResponse() (response *DescribeAssetUserKeyListResponse) {
    response = &DescribeAssetUserKeyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetUserKeyList
// This API is used to obtain the list of host account Keys.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetUserKeyList(request *DescribeAssetUserKeyListRequest) (response *DescribeAssetUserKeyListResponse, err error) {
    return c.DescribeAssetUserKeyListWithContext(context.Background(), request)
}

// DescribeAssetUserKeyList
// This API is used to obtain the list of host account Keys.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetUserKeyListWithContext(ctx context.Context, request *DescribeAssetUserKeyListRequest) (response *DescribeAssetUserKeyListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetUserKeyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetUserKeyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetUserKeyList require credential")
    }

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

func NewDescribeAssetUserListRequest() (request *DescribeAssetUserListRequest) {
    request = &DescribeAssetUserListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetUserList")
    
    
    return
}

func NewDescribeAssetUserListResponse() (response *DescribeAssetUserListResponse) {
    response = &DescribeAssetUserListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetUserList
// This API is used to obtain the list of accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAssetUserList(request *DescribeAssetUserListRequest) (response *DescribeAssetUserListResponse, err error) {
    return c.DescribeAssetUserListWithContext(context.Background(), request)
}

// DescribeAssetUserList
// This API is used to obtain the list of accounts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeAssetUserListWithContext(ctx context.Context, request *DescribeAssetUserListRequest) (response *DescribeAssetUserListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetUserListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetUserList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetUserList require credential")
    }

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

func NewDescribeAssetWebAppCountRequest() (request *DescribeAssetWebAppCountRequest) {
    request = &DescribeAssetWebAppCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebAppCount")
    
    
    return
}

func NewDescribeAssetWebAppCountResponse() (response *DescribeAssetWebAppCountResponse) {
    response = &DescribeAssetWebAppCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebAppCount
// This API is used to obtain the number of all web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppCount(request *DescribeAssetWebAppCountRequest) (response *DescribeAssetWebAppCountResponse, err error) {
    return c.DescribeAssetWebAppCountWithContext(context.Background(), request)
}

// DescribeAssetWebAppCount
// This API is used to obtain the number of all web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppCountWithContext(ctx context.Context, request *DescribeAssetWebAppCountRequest) (response *DescribeAssetWebAppCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebAppCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebAppCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebAppCount require credential")
    }

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

func NewDescribeAssetWebAppListRequest() (request *DescribeAssetWebAppListRequest) {
    request = &DescribeAssetWebAppListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebAppList")
    
    
    return
}

func NewDescribeAssetWebAppListResponse() (response *DescribeAssetWebAppListResponse) {
    response = &DescribeAssetWebAppListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebAppList
// This API is used to obtain the list of asset management web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppList(request *DescribeAssetWebAppListRequest) (response *DescribeAssetWebAppListResponse, err error) {
    return c.DescribeAssetWebAppListWithContext(context.Background(), request)
}

// DescribeAssetWebAppList
// This API is used to obtain the list of asset management web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppListWithContext(ctx context.Context, request *DescribeAssetWebAppListRequest) (response *DescribeAssetWebAppListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebAppListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebAppList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebAppList require credential")
    }

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

func NewDescribeAssetWebAppPluginListRequest() (request *DescribeAssetWebAppPluginListRequest) {
    request = &DescribeAssetWebAppPluginListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebAppPluginList")
    
    
    return
}

func NewDescribeAssetWebAppPluginListResponse() (response *DescribeAssetWebAppPluginListResponse) {
    response = &DescribeAssetWebAppPluginListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebAppPluginList
// This API is used to obtain the list of asset management Web application plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppPluginList(request *DescribeAssetWebAppPluginListRequest) (response *DescribeAssetWebAppPluginListResponse, err error) {
    return c.DescribeAssetWebAppPluginListWithContext(context.Background(), request)
}

// DescribeAssetWebAppPluginList
// This API is used to obtain the list of asset management Web application plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebAppPluginListWithContext(ctx context.Context, request *DescribeAssetWebAppPluginListRequest) (response *DescribeAssetWebAppPluginListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebAppPluginListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebAppPluginList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebAppPluginList require credential")
    }

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

func NewDescribeAssetWebFrameCountRequest() (request *DescribeAssetWebFrameCountRequest) {
    request = &DescribeAssetWebFrameCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebFrameCount")
    
    
    return
}

func NewDescribeAssetWebFrameCountResponse() (response *DescribeAssetWebFrameCountResponse) {
    response = &DescribeAssetWebFrameCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebFrameCount
// This API is used to obtain the number of all Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebFrameCount(request *DescribeAssetWebFrameCountRequest) (response *DescribeAssetWebFrameCountResponse, err error) {
    return c.DescribeAssetWebFrameCountWithContext(context.Background(), request)
}

// DescribeAssetWebFrameCount
// This API is used to obtain the number of all Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebFrameCountWithContext(ctx context.Context, request *DescribeAssetWebFrameCountRequest) (response *DescribeAssetWebFrameCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebFrameCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebFrameCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebFrameCount require credential")
    }

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

func NewDescribeAssetWebFrameListRequest() (request *DescribeAssetWebFrameListRequest) {
    request = &DescribeAssetWebFrameListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebFrameList")
    
    
    return
}

func NewDescribeAssetWebFrameListResponse() (response *DescribeAssetWebFrameListResponse) {
    response = &DescribeAssetWebFrameListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebFrameList
// This API is used to obtain the list of asset management Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebFrameList(request *DescribeAssetWebFrameListRequest) (response *DescribeAssetWebFrameListResponse, err error) {
    return c.DescribeAssetWebFrameListWithContext(context.Background(), request)
}

// DescribeAssetWebFrameList
// This API is used to obtain the list of asset management Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebFrameListWithContext(ctx context.Context, request *DescribeAssetWebFrameListRequest) (response *DescribeAssetWebFrameListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebFrameListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebFrameList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebFrameList require credential")
    }

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

func NewDescribeAssetWebLocationCountRequest() (request *DescribeAssetWebLocationCountRequest) {
    request = &DescribeAssetWebLocationCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebLocationCount")
    
    
    return
}

func NewDescribeAssetWebLocationCountResponse() (response *DescribeAssetWebLocationCountResponse) {
    response = &DescribeAssetWebLocationCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebLocationCount
// This API is used to obtain the total number of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationCount(request *DescribeAssetWebLocationCountRequest) (response *DescribeAssetWebLocationCountResponse, err error) {
    return c.DescribeAssetWebLocationCountWithContext(context.Background(), request)
}

// DescribeAssetWebLocationCount
// This API is used to obtain the total number of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationCountWithContext(ctx context.Context, request *DescribeAssetWebLocationCountRequest) (response *DescribeAssetWebLocationCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebLocationCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebLocationCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebLocationCount require credential")
    }

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

func NewDescribeAssetWebLocationInfoRequest() (request *DescribeAssetWebLocationInfoRequest) {
    request = &DescribeAssetWebLocationInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebLocationInfo")
    
    
    return
}

func NewDescribeAssetWebLocationInfoResponse() (response *DescribeAssetWebLocationInfoResponse) {
    response = &DescribeAssetWebLocationInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebLocationInfo
// This API is used to obtain the Web site details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationInfo(request *DescribeAssetWebLocationInfoRequest) (response *DescribeAssetWebLocationInfoResponse, err error) {
    return c.DescribeAssetWebLocationInfoWithContext(context.Background(), request)
}

// DescribeAssetWebLocationInfo
// This API is used to obtain the Web site details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationInfoWithContext(ctx context.Context, request *DescribeAssetWebLocationInfoRequest) (response *DescribeAssetWebLocationInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebLocationInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebLocationInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebLocationInfo require credential")
    }

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

func NewDescribeAssetWebLocationListRequest() (request *DescribeAssetWebLocationListRequest) {
    request = &DescribeAssetWebLocationListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebLocationList")
    
    
    return
}

func NewDescribeAssetWebLocationListResponse() (response *DescribeAssetWebLocationListResponse) {
    response = &DescribeAssetWebLocationListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebLocationList
// This API is used to obtain the list of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationList(request *DescribeAssetWebLocationListRequest) (response *DescribeAssetWebLocationListResponse, err error) {
    return c.DescribeAssetWebLocationListWithContext(context.Background(), request)
}

// DescribeAssetWebLocationList
// This API is used to obtain the list of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationListWithContext(ctx context.Context, request *DescribeAssetWebLocationListRequest) (response *DescribeAssetWebLocationListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebLocationListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebLocationList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebLocationList require credential")
    }

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

func NewDescribeAssetWebLocationPathListRequest() (request *DescribeAssetWebLocationPathListRequest) {
    request = &DescribeAssetWebLocationPathListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebLocationPathList")
    
    
    return
}

func NewDescribeAssetWebLocationPathListResponse() (response *DescribeAssetWebLocationPathListResponse) {
    response = &DescribeAssetWebLocationPathListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebLocationPathList
// This API is used to obtain the list of Web sites' virtual directories.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationPathList(request *DescribeAssetWebLocationPathListRequest) (response *DescribeAssetWebLocationPathListResponse, err error) {
    return c.DescribeAssetWebLocationPathListWithContext(context.Background(), request)
}

// DescribeAssetWebLocationPathList
// This API is used to obtain the list of Web sites' virtual directories.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebLocationPathListWithContext(ctx context.Context, request *DescribeAssetWebLocationPathListRequest) (response *DescribeAssetWebLocationPathListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebLocationPathListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebLocationPathList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebLocationPathList require credential")
    }

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

func NewDescribeAssetWebServiceCountRequest() (request *DescribeAssetWebServiceCountRequest) {
    request = &DescribeAssetWebServiceCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebServiceCount")
    
    
    return
}

func NewDescribeAssetWebServiceCountResponse() (response *DescribeAssetWebServiceCountResponse) {
    response = &DescribeAssetWebServiceCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebServiceCount
// This API is used to obtain the number of all web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebServiceCount(request *DescribeAssetWebServiceCountRequest) (response *DescribeAssetWebServiceCountResponse, err error) {
    return c.DescribeAssetWebServiceCountWithContext(context.Background(), request)
}

// DescribeAssetWebServiceCount
// This API is used to obtain the number of all web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebServiceCountWithContext(ctx context.Context, request *DescribeAssetWebServiceCountRequest) (response *DescribeAssetWebServiceCountResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebServiceCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebServiceCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebServiceCount require credential")
    }

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

func NewDescribeAssetWebServiceInfoListRequest() (request *DescribeAssetWebServiceInfoListRequest) {
    request = &DescribeAssetWebServiceInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebServiceInfoList")
    
    
    return
}

func NewDescribeAssetWebServiceInfoListResponse() (response *DescribeAssetWebServiceInfoListResponse) {
    response = &DescribeAssetWebServiceInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebServiceInfoList
// This API is used to query the list of asset management Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetWebServiceInfoList(request *DescribeAssetWebServiceInfoListRequest) (response *DescribeAssetWebServiceInfoListResponse, err error) {
    return c.DescribeAssetWebServiceInfoListWithContext(context.Background(), request)
}

// DescribeAssetWebServiceInfoList
// This API is used to query the list of asset management Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAssetWebServiceInfoListWithContext(ctx context.Context, request *DescribeAssetWebServiceInfoListRequest) (response *DescribeAssetWebServiceInfoListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebServiceInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebServiceInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebServiceInfoList require credential")
    }

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

func NewDescribeAssetWebServiceProcessListRequest() (request *DescribeAssetWebServiceProcessListRequest) {
    request = &DescribeAssetWebServiceProcessListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAssetWebServiceProcessList")
    
    
    return
}

func NewDescribeAssetWebServiceProcessListResponse() (response *DescribeAssetWebServiceProcessListResponse) {
    response = &DescribeAssetWebServiceProcessListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAssetWebServiceProcessList
// This API is used to obtain the list of processes associated with Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebServiceProcessList(request *DescribeAssetWebServiceProcessListRequest) (response *DescribeAssetWebServiceProcessListResponse, err error) {
    return c.DescribeAssetWebServiceProcessListWithContext(context.Background(), request)
}

// DescribeAssetWebServiceProcessList
// This API is used to obtain the list of processes associated with Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeAssetWebServiceProcessListWithContext(ctx context.Context, request *DescribeAssetWebServiceProcessListRequest) (response *DescribeAssetWebServiceProcessListResponse, err error) {
    if request == nil {
        request = NewDescribeAssetWebServiceProcessListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAssetWebServiceProcessList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAssetWebServiceProcessList require credential")
    }

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

func NewDescribeAttackEventInfoRequest() (request *DescribeAttackEventInfoRequest) {
    request = &DescribeAttackEventInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackEventInfo")
    
    
    return
}

func NewDescribeAttackEventInfoResponse() (response *DescribeAttackEventInfoResponse) {
    response = &DescribeAttackEventInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackEventInfo
// This API is used to obtain network attack details.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackEventInfo(request *DescribeAttackEventInfoRequest) (response *DescribeAttackEventInfoResponse, err error) {
    return c.DescribeAttackEventInfoWithContext(context.Background(), request)
}

// DescribeAttackEventInfo
// This API is used to obtain network attack details.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackEventInfoWithContext(ctx context.Context, request *DescribeAttackEventInfoRequest) (response *DescribeAttackEventInfoResponse, err error) {
    if request == nil {
        request = NewDescribeAttackEventInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackEventInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackEventInfo require credential")
    }

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

func NewDescribeAttackEventsRequest() (request *DescribeAttackEventsRequest) {
    request = &DescribeAttackEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackEvents")
    
    
    return
}

func NewDescribeAttackEventsResponse() (response *DescribeAttackEventsResponse) {
    response = &DescribeAttackEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackEvents
// This API is used to display the list of network attack detection events in pagination.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackEvents(request *DescribeAttackEventsRequest) (response *DescribeAttackEventsResponse, err error) {
    return c.DescribeAttackEventsWithContext(context.Background(), request)
}

// DescribeAttackEvents
// This API is used to display the list of network attack detection events in pagination.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackEventsWithContext(ctx context.Context, request *DescribeAttackEventsRequest) (response *DescribeAttackEventsResponse, err error) {
    if request == nil {
        request = NewDescribeAttackEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackEvents require credential")
    }

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

func NewDescribeAttackLogsRequest() (request *DescribeAttackLogsRequest) {
    request = &DescribeAttackLogsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackLogs")
    
    
    return
}

func NewDescribeAttackLogsResponse() (response *DescribeAttackLogsResponse) {
    response = &DescribeAttackLogsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackLogs
// DescribeAttackEvents 代替
//
// 
//
// This API is used to display the list of network attack logs in pagination.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackLogs(request *DescribeAttackLogsRequest) (response *DescribeAttackLogsResponse, err error) {
    return c.DescribeAttackLogsWithContext(context.Background(), request)
}

// DescribeAttackLogs
// DescribeAttackEvents 代替
//
// 
//
// This API is used to display the list of network attack logs in pagination.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackLogsWithContext(ctx context.Context, request *DescribeAttackLogsRequest) (response *DescribeAttackLogsResponse, err error) {
    if request == nil {
        request = NewDescribeAttackLogsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackLogs")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackLogs require credential")
    }

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

func NewDescribeAttackSourceRequest() (request *DescribeAttackSourceRequest) {
    request = &DescribeAttackSourceRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackSource")
    
    
    return
}

func NewDescribeAttackSourceResponse() (response *DescribeAttackSourceResponse) {
    response = &DescribeAttackSourceResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackSource
// 已废弃
//
// 
//
// This API is used to backtrack attacks.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackSource(request *DescribeAttackSourceRequest) (response *DescribeAttackSourceResponse, err error) {
    return c.DescribeAttackSourceWithContext(context.Background(), request)
}

// DescribeAttackSource
// 已废弃
//
// 
//
// This API is used to backtrack attacks.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackSourceWithContext(ctx context.Context, request *DescribeAttackSourceRequest) (response *DescribeAttackSourceResponse, err error) {
    if request == nil {
        request = NewDescribeAttackSourceRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackSource")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackSource require credential")
    }

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

func NewDescribeAttackSourceEventsRequest() (request *DescribeAttackSourceEventsRequest) {
    request = &DescribeAttackSourceEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackSourceEvents")
    
    
    return
}

func NewDescribeAttackSourceEventsResponse() (response *DescribeAttackSourceEventsResponse) {
    response = &DescribeAttackSourceEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackSourceEvents
// 已废弃
//
// 
//
// This API is used to query attack backtracking events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackSourceEvents(request *DescribeAttackSourceEventsRequest) (response *DescribeAttackSourceEventsResponse, err error) {
    return c.DescribeAttackSourceEventsWithContext(context.Background(), request)
}

// DescribeAttackSourceEvents
// 已废弃
//
// 
//
// This API is used to query attack backtracking events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackSourceEventsWithContext(ctx context.Context, request *DescribeAttackSourceEventsRequest) (response *DescribeAttackSourceEventsResponse, err error) {
    if request == nil {
        request = NewDescribeAttackSourceEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackSourceEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackSourceEvents require credential")
    }

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

func NewDescribeAttackStatisticsRequest() (request *DescribeAttackStatisticsRequest) {
    request = &DescribeAttackStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackStatistics")
    
    
    return
}

func NewDescribeAttackStatisticsResponse() (response *DescribeAttackStatisticsResponse) {
    response = &DescribeAttackStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackStatistics
// This API is used to obtain the statistics of network attack data.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackStatistics(request *DescribeAttackStatisticsRequest) (response *DescribeAttackStatisticsResponse, err error) {
    return c.DescribeAttackStatisticsWithContext(context.Background(), request)
}

// DescribeAttackStatistics
// This API is used to obtain the statistics of network attack data.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackStatisticsWithContext(ctx context.Context, request *DescribeAttackStatisticsRequest) (response *DescribeAttackStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeAttackStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackStatistics require credential")
    }

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

func NewDescribeAttackTopRequest() (request *DescribeAttackTopRequest) {
    request = &DescribeAttackTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackTop")
    
    
    return
}

func NewDescribeAttackTopResponse() (response *DescribeAttackTopResponse) {
    response = &DescribeAttackTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackTop
// This API is used to obtain the list of Top 5 network attacks.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackTop(request *DescribeAttackTopRequest) (response *DescribeAttackTopResponse, err error) {
    return c.DescribeAttackTopWithContext(context.Background(), request)
}

// DescribeAttackTop
// This API is used to obtain the list of Top 5 network attacks.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackTopWithContext(ctx context.Context, request *DescribeAttackTopRequest) (response *DescribeAttackTopResponse, err error) {
    if request == nil {
        request = NewDescribeAttackTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackTop require credential")
    }

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

func NewDescribeAttackTrendsRequest() (request *DescribeAttackTrendsRequest) {
    request = &DescribeAttackTrendsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackTrends")
    
    
    return
}

func NewDescribeAttackTrendsResponse() (response *DescribeAttackTrendsResponse) {
    response = &DescribeAttackTrendsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackTrends
// This API is used to obtain the network attack trend data.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackTrends(request *DescribeAttackTrendsRequest) (response *DescribeAttackTrendsResponse, err error) {
    return c.DescribeAttackTrendsWithContext(context.Background(), request)
}

// DescribeAttackTrends
// This API is used to obtain the network attack trend data.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeAttackTrendsWithContext(ctx context.Context, request *DescribeAttackTrendsRequest) (response *DescribeAttackTrendsResponse, err error) {
    if request == nil {
        request = NewDescribeAttackTrendsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackTrends")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackTrends require credential")
    }

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

func NewDescribeAttackVulTypeListRequest() (request *DescribeAttackVulTypeListRequest) {
    request = &DescribeAttackVulTypeListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAttackVulTypeList")
    
    
    return
}

func NewDescribeAttackVulTypeListResponse() (response *DescribeAttackVulTypeListResponse) {
    response = &DescribeAttackVulTypeListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAttackVulTypeList
// This API is used to obtain the list of network attack threat types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeAttackVulTypeList(request *DescribeAttackVulTypeListRequest) (response *DescribeAttackVulTypeListResponse, err error) {
    return c.DescribeAttackVulTypeListWithContext(context.Background(), request)
}

// DescribeAttackVulTypeList
// This API is used to obtain the list of network attack threat types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeAttackVulTypeListWithContext(ctx context.Context, request *DescribeAttackVulTypeListRequest) (response *DescribeAttackVulTypeListResponse, err error) {
    if request == nil {
        request = NewDescribeAttackVulTypeListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAttackVulTypeList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAttackVulTypeList require credential")
    }

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

func NewDescribeAvailableExpertServiceDetailRequest() (request *DescribeAvailableExpertServiceDetailRequest) {
    request = &DescribeAvailableExpertServiceDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeAvailableExpertServiceDetail")
    
    
    return
}

func NewDescribeAvailableExpertServiceDetailResponse() (response *DescribeAvailableExpertServiceDetailResponse) {
    response = &DescribeAvailableExpertServiceDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeAvailableExpertServiceDetail
// This API is used to obtain available order details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeAvailableExpertServiceDetail(request *DescribeAvailableExpertServiceDetailRequest) (response *DescribeAvailableExpertServiceDetailResponse, err error) {
    return c.DescribeAvailableExpertServiceDetailWithContext(context.Background(), request)
}

// DescribeAvailableExpertServiceDetail
// This API is used to obtain available order details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeAvailableExpertServiceDetailWithContext(ctx context.Context, request *DescribeAvailableExpertServiceDetailRequest) (response *DescribeAvailableExpertServiceDetailResponse, err error) {
    if request == nil {
        request = NewDescribeAvailableExpertServiceDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeAvailableExpertServiceDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeAvailableExpertServiceDetail require credential")
    }

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

func NewDescribeBanModeRequest() (request *DescribeBanModeRequest) {
    request = &DescribeBanModeRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBanMode")
    
    
    return
}

func NewDescribeBanModeResponse() (response *DescribeBanModeResponse) {
    response = &DescribeBanModeResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBanMode
// This API is used to obtain the brute-force blocking mode.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBanMode(request *DescribeBanModeRequest) (response *DescribeBanModeResponse, err error) {
    return c.DescribeBanModeWithContext(context.Background(), request)
}

// DescribeBanMode
// This API is used to obtain the brute-force blocking mode.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBanModeWithContext(ctx context.Context, request *DescribeBanModeRequest) (response *DescribeBanModeResponse, err error) {
    if request == nil {
        request = NewDescribeBanModeRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBanMode")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBanMode require credential")
    }

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

func NewDescribeBanRegionsRequest() (request *DescribeBanRegionsRequest) {
    request = &DescribeBanRegionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBanRegions")
    
    
    return
}

func NewDescribeBanRegionsResponse() (response *DescribeBanRegionsResponse) {
    response = &DescribeBanRegionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBanRegions
// This API is used to obtain the block region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBanRegions(request *DescribeBanRegionsRequest) (response *DescribeBanRegionsResponse, err error) {
    return c.DescribeBanRegionsWithContext(context.Background(), request)
}

// DescribeBanRegions
// This API is used to obtain the block region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBanRegionsWithContext(ctx context.Context, request *DescribeBanRegionsRequest) (response *DescribeBanRegionsResponse, err error) {
    if request == nil {
        request = NewDescribeBanRegionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBanRegions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBanRegions require credential")
    }

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

func NewDescribeBanStatusRequest() (request *DescribeBanStatusRequest) {
    request = &DescribeBanStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBanStatus")
    
    
    return
}

func NewDescribeBanStatusResponse() (response *DescribeBanStatusResponse) {
    response = &DescribeBanStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBanStatus
// This API is used to obtain the block button status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBanStatus(request *DescribeBanStatusRequest) (response *DescribeBanStatusResponse, err error) {
    return c.DescribeBanStatusWithContext(context.Background(), request)
}

// DescribeBanStatus
// This API is used to obtain the block button status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBanStatusWithContext(ctx context.Context, request *DescribeBanStatusRequest) (response *DescribeBanStatusResponse, err error) {
    if request == nil {
        request = NewDescribeBanStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBanStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBanStatus require credential")
    }

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

func NewDescribeBanWhiteListRequest() (request *DescribeBanWhiteListRequest) {
    request = &DescribeBanWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBanWhiteList")
    
    
    return
}

func NewDescribeBanWhiteListResponse() (response *DescribeBanWhiteListResponse) {
    response = &DescribeBanWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBanWhiteList
// This API is used to obtain the blocking allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBanWhiteList(request *DescribeBanWhiteListRequest) (response *DescribeBanWhiteListResponse, err error) {
    return c.DescribeBanWhiteListWithContext(context.Background(), request)
}

// DescribeBanWhiteList
// This API is used to obtain the blocking allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBanWhiteListWithContext(ctx context.Context, request *DescribeBanWhiteListRequest) (response *DescribeBanWhiteListResponse, err error) {
    if request == nil {
        request = NewDescribeBanWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBanWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBanWhiteList require credential")
    }

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

func NewDescribeBaselineBasicInfoRequest() (request *DescribeBaselineBasicInfoRequest) {
    request = &DescribeBaselineBasicInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineBasicInfo")
    
    
    return
}

func NewDescribeBaselineBasicInfoResponse() (response *DescribeBaselineBasicInfoResponse) {
    response = &DescribeBaselineBasicInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineBasicInfo
// This API is used to query the list of baseline basic information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineBasicInfo(request *DescribeBaselineBasicInfoRequest) (response *DescribeBaselineBasicInfoResponse, err error) {
    return c.DescribeBaselineBasicInfoWithContext(context.Background(), request)
}

// DescribeBaselineBasicInfo
// This API is used to query the list of baseline basic information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineBasicInfoWithContext(ctx context.Context, request *DescribeBaselineBasicInfoRequest) (response *DescribeBaselineBasicInfoResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineBasicInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineBasicInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineBasicInfo require credential")
    }

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

func NewDescribeBaselineDefaultStrategyListRequest() (request *DescribeBaselineDefaultStrategyListRequest) {
    request = &DescribeBaselineDefaultStrategyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineDefaultStrategyList")
    
    
    return
}

func NewDescribeBaselineDefaultStrategyListResponse() (response *DescribeBaselineDefaultStrategyListResponse) {
    response = &DescribeBaselineDefaultStrategyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineDefaultStrategyList
// This API is used to query the list information of default policies of the baseline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeBaselineDefaultStrategyList(request *DescribeBaselineDefaultStrategyListRequest) (response *DescribeBaselineDefaultStrategyListResponse, err error) {
    return c.DescribeBaselineDefaultStrategyListWithContext(context.Background(), request)
}

// DescribeBaselineDefaultStrategyList
// This API is used to query the list information of default policies of the baseline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeBaselineDefaultStrategyListWithContext(ctx context.Context, request *DescribeBaselineDefaultStrategyListRequest) (response *DescribeBaselineDefaultStrategyListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineDefaultStrategyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineDefaultStrategyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineDefaultStrategyList require credential")
    }

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

func NewDescribeBaselineDetailRequest() (request *DescribeBaselineDetailRequest) {
    request = &DescribeBaselineDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineDetail")
    
    
    return
}

func NewDescribeBaselineDetailResponse() (response *DescribeBaselineDetailResponse) {
    response = &DescribeBaselineDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineDetail
// This API is used to query baseline details by baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineDetail(request *DescribeBaselineDetailRequest) (response *DescribeBaselineDetailResponse, err error) {
    return c.DescribeBaselineDetailWithContext(context.Background(), request)
}

// DescribeBaselineDetail
// This API is used to query baseline details by baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineDetailWithContext(ctx context.Context, request *DescribeBaselineDetailRequest) (response *DescribeBaselineDetailResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineDetail require credential")
    }

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

func NewDescribeBaselineEffectHostListRequest() (request *DescribeBaselineEffectHostListRequest) {
    request = &DescribeBaselineEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineEffectHostList")
    
    
    return
}

func NewDescribeBaselineEffectHostListResponse() (response *DescribeBaselineEffectHostListResponse) {
    response = &DescribeBaselineEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineEffectHostList
// This API is used to query the list of hosts affected by a baseline based on baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineEffectHostList(request *DescribeBaselineEffectHostListRequest) (response *DescribeBaselineEffectHostListResponse, err error) {
    return c.DescribeBaselineEffectHostListWithContext(context.Background(), request)
}

// DescribeBaselineEffectHostList
// This API is used to query the list of hosts affected by a baseline based on baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineEffectHostListWithContext(ctx context.Context, request *DescribeBaselineEffectHostListRequest) (response *DescribeBaselineEffectHostListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineEffectHostList require credential")
    }

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

func NewDescribeBaselineHostDetectListRequest() (request *DescribeBaselineHostDetectListRequest) {
    request = &DescribeBaselineHostDetectListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineHostDetectList")
    
    
    return
}

func NewDescribeBaselineHostDetectListResponse() (response *DescribeBaselineHostDetectListResponse) {
    response = &DescribeBaselineHostDetectListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineHostDetectList
// This API is used to obtain the list of hosts for baseline detection.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineHostDetectList(request *DescribeBaselineHostDetectListRequest) (response *DescribeBaselineHostDetectListResponse, err error) {
    return c.DescribeBaselineHostDetectListWithContext(context.Background(), request)
}

// DescribeBaselineHostDetectList
// This API is used to obtain the list of hosts for baseline detection.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineHostDetectListWithContext(ctx context.Context, request *DescribeBaselineHostDetectListRequest) (response *DescribeBaselineHostDetectListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineHostDetectListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineHostDetectList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineHostDetectList require credential")
    }

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

func NewDescribeBaselineHostTopRequest() (request *DescribeBaselineHostTopRequest) {
    request = &DescribeBaselineHostTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineHostTop")
    
    
    return
}

func NewDescribeBaselineHostTopResponse() (response *DescribeBaselineHostTopResponse) {
    response = &DescribeBaselineHostTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineHostTop
// This API is used to return Top N risky servers.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineHostTop(request *DescribeBaselineHostTopRequest) (response *DescribeBaselineHostTopResponse, err error) {
    return c.DescribeBaselineHostTopWithContext(context.Background(), request)
}

// DescribeBaselineHostTop
// This API is used to return Top N risky servers.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineHostTopWithContext(ctx context.Context, request *DescribeBaselineHostTopRequest) (response *DescribeBaselineHostTopResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineHostTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineHostTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineHostTop require credential")
    }

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

func NewDescribeBaselineItemDetectListRequest() (request *DescribeBaselineItemDetectListRequest) {
    request = &DescribeBaselineItemDetectListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineItemDetectList")
    
    
    return
}

func NewDescribeBaselineItemDetectListResponse() (response *DescribeBaselineItemDetectListResponse) {
    response = &DescribeBaselineItemDetectListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineItemDetectList
// This API is used to obtain the list of baseline detection items.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineItemDetectList(request *DescribeBaselineItemDetectListRequest) (response *DescribeBaselineItemDetectListResponse, err error) {
    return c.DescribeBaselineItemDetectListWithContext(context.Background(), request)
}

// DescribeBaselineItemDetectList
// This API is used to obtain the list of baseline detection items.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineItemDetectListWithContext(ctx context.Context, request *DescribeBaselineItemDetectListRequest) (response *DescribeBaselineItemDetectListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineItemDetectListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineItemDetectList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineItemDetectList require credential")
    }

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

func NewDescribeBaselineItemListRequest() (request *DescribeBaselineItemListRequest) {
    request = &DescribeBaselineItemListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineItemList")
    
    
    return
}

func NewDescribeBaselineItemListResponse() (response *DescribeBaselineItemListResponse) {
    response = &DescribeBaselineItemListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineItemList
// This API is used to obtain the list of check results on baseline check items.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineItemList(request *DescribeBaselineItemListRequest) (response *DescribeBaselineItemListResponse, err error) {
    return c.DescribeBaselineItemListWithContext(context.Background(), request)
}

// DescribeBaselineItemList
// This API is used to obtain the list of check results on baseline check items.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineItemListWithContext(ctx context.Context, request *DescribeBaselineItemListRequest) (response *DescribeBaselineItemListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineItemListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineItemList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineItemList require credential")
    }

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

func NewDescribeBaselineListRequest() (request *DescribeBaselineListRequest) {
    request = &DescribeBaselineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineList")
    
    
    return
}

func NewDescribeBaselineListResponse() (response *DescribeBaselineListResponse) {
    response = &DescribeBaselineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineList
// This API is used to query the information of the baseline list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineList(request *DescribeBaselineListRequest) (response *DescribeBaselineListResponse, err error) {
    return c.DescribeBaselineListWithContext(context.Background(), request)
}

// DescribeBaselineList
// This API is used to query the information of the baseline list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineListWithContext(ctx context.Context, request *DescribeBaselineListRequest) (response *DescribeBaselineListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineList require credential")
    }

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

func NewDescribeBaselinePolicyListRequest() (request *DescribeBaselinePolicyListRequest) {
    request = &DescribeBaselinePolicyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselinePolicyList")
    
    
    return
}

func NewDescribeBaselinePolicyListResponse() (response *DescribeBaselinePolicyListResponse) {
    response = &DescribeBaselinePolicyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselinePolicyList
// This API is used to obtain the list of baseline policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselinePolicyList(request *DescribeBaselinePolicyListRequest) (response *DescribeBaselinePolicyListResponse, err error) {
    return c.DescribeBaselinePolicyListWithContext(context.Background(), request)
}

// DescribeBaselinePolicyList
// This API is used to obtain the list of baseline policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselinePolicyListWithContext(ctx context.Context, request *DescribeBaselinePolicyListRequest) (response *DescribeBaselinePolicyListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselinePolicyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselinePolicyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselinePolicyList require credential")
    }

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

func NewDescribeBaselineRuleRequest() (request *DescribeBaselineRuleRequest) {
    request = &DescribeBaselineRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineRule")
    
    
    return
}

func NewDescribeBaselineRuleResponse() (response *DescribeBaselineRuleResponse) {
    response = &DescribeBaselineRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineRule
// This API is used to query the information on corresponding check items based on baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineRule(request *DescribeBaselineRuleRequest) (response *DescribeBaselineRuleResponse, err error) {
    return c.DescribeBaselineRuleWithContext(context.Background(), request)
}

// DescribeBaselineRule
// This API is used to query the information on corresponding check items based on baseline ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineRuleWithContext(ctx context.Context, request *DescribeBaselineRuleRequest) (response *DescribeBaselineRuleResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineRule require credential")
    }

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

func NewDescribeBaselineScanScheduleRequest() (request *DescribeBaselineScanScheduleRequest) {
    request = &DescribeBaselineScanScheduleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineScanSchedule")
    
    
    return
}

func NewDescribeBaselineScanScheduleResponse() (response *DescribeBaselineScanScheduleResponse) {
    response = &DescribeBaselineScanScheduleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineScanSchedule
// This API is used to query the baseline detection progress by task ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBaselineScanSchedule(request *DescribeBaselineScanScheduleRequest) (response *DescribeBaselineScanScheduleResponse, err error) {
    return c.DescribeBaselineScanScheduleWithContext(context.Background(), request)
}

// DescribeBaselineScanSchedule
// This API is used to query the baseline detection progress by task ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBaselineScanScheduleWithContext(ctx context.Context, request *DescribeBaselineScanScheduleRequest) (response *DescribeBaselineScanScheduleResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineScanScheduleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineScanSchedule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineScanSchedule require credential")
    }

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

func NewDescribeBaselineStrategyDetailRequest() (request *DescribeBaselineStrategyDetailRequest) {
    request = &DescribeBaselineStrategyDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineStrategyDetail")
    
    
    return
}

func NewDescribeBaselineStrategyDetailResponse() (response *DescribeBaselineStrategyDetailResponse) {
    response = &DescribeBaselineStrategyDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineStrategyDetail
// This API is used to query policy details by baseline policy ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBaselineStrategyDetail(request *DescribeBaselineStrategyDetailRequest) (response *DescribeBaselineStrategyDetailResponse, err error) {
    return c.DescribeBaselineStrategyDetailWithContext(context.Background(), request)
}

// DescribeBaselineStrategyDetail
// This API is used to query policy details by baseline policy ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBaselineStrategyDetailWithContext(ctx context.Context, request *DescribeBaselineStrategyDetailRequest) (response *DescribeBaselineStrategyDetailResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineStrategyDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineStrategyDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineStrategyDetail require credential")
    }

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

func NewDescribeBaselineStrategyListRequest() (request *DescribeBaselineStrategyListRequest) {
    request = &DescribeBaselineStrategyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineStrategyList")
    
    
    return
}

func NewDescribeBaselineStrategyListResponse() (response *DescribeBaselineStrategyListResponse) {
    response = &DescribeBaselineStrategyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineStrategyList
// This API is used to query the information of baseline policies under the same user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineStrategyList(request *DescribeBaselineStrategyListRequest) (response *DescribeBaselineStrategyListResponse, err error) {
    return c.DescribeBaselineStrategyListWithContext(context.Background(), request)
}

// DescribeBaselineStrategyList
// This API is used to query the information of baseline policies under the same user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineStrategyListWithContext(ctx context.Context, request *DescribeBaselineStrategyListRequest) (response *DescribeBaselineStrategyListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineStrategyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineStrategyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineStrategyList require credential")
    }

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

func NewDescribeBaselineTopRequest() (request *DescribeBaselineTopRequest) {
    request = &DescribeBaselineTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineTop")
    
    
    return
}

func NewDescribeBaselineTopResponse() (response *DescribeBaselineTopResponse) {
    response = &DescribeBaselineTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineTop
// This API is used to query TOP baseline detection items based on policy IDs.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineTop(request *DescribeBaselineTopRequest) (response *DescribeBaselineTopResponse, err error) {
    return c.DescribeBaselineTopWithContext(context.Background(), request)
}

// DescribeBaselineTop
// This API is used to query TOP baseline detection items based on policy IDs.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeBaselineTopWithContext(ctx context.Context, request *DescribeBaselineTopRequest) (response *DescribeBaselineTopResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineTop require credential")
    }

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

func NewDescribeBaselineWeakPasswordListRequest() (request *DescribeBaselineWeakPasswordListRequest) {
    request = &DescribeBaselineWeakPasswordListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBaselineWeakPasswordList")
    
    
    return
}

func NewDescribeBaselineWeakPasswordListResponse() (response *DescribeBaselineWeakPasswordListResponse) {
    response = &DescribeBaselineWeakPasswordListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBaselineWeakPasswordList
// This API is used to obtain the list of baseline weak passwords.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineWeakPasswordList(request *DescribeBaselineWeakPasswordListRequest) (response *DescribeBaselineWeakPasswordListResponse, err error) {
    return c.DescribeBaselineWeakPasswordListWithContext(context.Background(), request)
}

// DescribeBaselineWeakPasswordList
// This API is used to obtain the list of baseline weak passwords.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeBaselineWeakPasswordListWithContext(ctx context.Context, request *DescribeBaselineWeakPasswordListRequest) (response *DescribeBaselineWeakPasswordListResponse, err error) {
    if request == nil {
        request = NewDescribeBaselineWeakPasswordListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBaselineWeakPasswordList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBaselineWeakPasswordList require credential")
    }

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

func NewDescribeBashEventsRequest() (request *DescribeBashEventsRequest) {
    request = &DescribeBashEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashEvents")
    
    
    return
}

func NewDescribeBashEventsResponse() (response *DescribeBashEventsResponse) {
    response = &DescribeBashEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashEvents
// This API is used to obtain the high-risk command list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashEvents(request *DescribeBashEventsRequest) (response *DescribeBashEventsResponse, err error) {
    return c.DescribeBashEventsWithContext(context.Background(), request)
}

// DescribeBashEvents
// This API is used to obtain the high-risk command list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashEventsWithContext(ctx context.Context, request *DescribeBashEventsRequest) (response *DescribeBashEventsResponse, err error) {
    if request == nil {
        request = NewDescribeBashEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashEvents require credential")
    }

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

func NewDescribeBashEventsInfoRequest() (request *DescribeBashEventsInfoRequest) {
    request = &DescribeBashEventsInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashEventsInfo")
    
    
    return
}

func NewDescribeBashEventsInfoResponse() (response *DescribeBashEventsInfoResponse) {
    response = &DescribeBashEventsInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashEventsInfo
// This API is used to query high-risk command event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeBashEventsInfo(request *DescribeBashEventsInfoRequest) (response *DescribeBashEventsInfoResponse, err error) {
    return c.DescribeBashEventsInfoWithContext(context.Background(), request)
}

// DescribeBashEventsInfo
// This API is used to query high-risk command event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeBashEventsInfoWithContext(ctx context.Context, request *DescribeBashEventsInfoRequest) (response *DescribeBashEventsInfoResponse, err error) {
    if request == nil {
        request = NewDescribeBashEventsInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashEventsInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashEventsInfo require credential")
    }

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

func NewDescribeBashEventsInfoNewRequest() (request *DescribeBashEventsInfoNewRequest) {
    request = &DescribeBashEventsInfoNewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashEventsInfoNew")
    
    
    return
}

func NewDescribeBashEventsInfoNewResponse() (response *DescribeBashEventsInfoNewResponse) {
    response = &DescribeBashEventsInfoNewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashEventsInfoNew
// This API is used to query high-risk command event details (new).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeBashEventsInfoNew(request *DescribeBashEventsInfoNewRequest) (response *DescribeBashEventsInfoNewResponse, err error) {
    return c.DescribeBashEventsInfoNewWithContext(context.Background(), request)
}

// DescribeBashEventsInfoNew
// This API is used to query high-risk command event details (new).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeBashEventsInfoNewWithContext(ctx context.Context, request *DescribeBashEventsInfoNewRequest) (response *DescribeBashEventsInfoNewResponse, err error) {
    if request == nil {
        request = NewDescribeBashEventsInfoNewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashEventsInfoNew")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashEventsInfoNew require credential")
    }

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

func NewDescribeBashEventsNewRequest() (request *DescribeBashEventsNewRequest) {
    request = &DescribeBashEventsNewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashEventsNew")
    
    
    return
}

func NewDescribeBashEventsNewResponse() (response *DescribeBashEventsNewResponse) {
    response = &DescribeBashEventsNewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashEventsNew
// This API is used to obtain the list of high-risk commands (new).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashEventsNew(request *DescribeBashEventsNewRequest) (response *DescribeBashEventsNewResponse, err error) {
    return c.DescribeBashEventsNewWithContext(context.Background(), request)
}

// DescribeBashEventsNew
// This API is used to obtain the list of high-risk commands (new).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashEventsNewWithContext(ctx context.Context, request *DescribeBashEventsNewRequest) (response *DescribeBashEventsNewResponse, err error) {
    if request == nil {
        request = NewDescribeBashEventsNewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashEventsNew")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashEventsNew require credential")
    }

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

func NewDescribeBashPoliciesRequest() (request *DescribeBashPoliciesRequest) {
    request = &DescribeBashPoliciesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashPolicies")
    
    
    return
}

func NewDescribeBashPoliciesResponse() (response *DescribeBashPoliciesResponse) {
    response = &DescribeBashPoliciesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashPolicies
// This API is used to obtain the list of high-risk command policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashPolicies(request *DescribeBashPoliciesRequest) (response *DescribeBashPoliciesResponse, err error) {
    return c.DescribeBashPoliciesWithContext(context.Background(), request)
}

// DescribeBashPolicies
// This API is used to obtain the list of high-risk command policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashPoliciesWithContext(ctx context.Context, request *DescribeBashPoliciesRequest) (response *DescribeBashPoliciesResponse, err error) {
    if request == nil {
        request = NewDescribeBashPoliciesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashPolicies")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashPolicies require credential")
    }

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

func NewDescribeBashRulesRequest() (request *DescribeBashRulesRequest) {
    request = &DescribeBashRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBashRules")
    
    
    return
}

func NewDescribeBashRulesResponse() (response *DescribeBashRulesResponse) {
    response = &DescribeBashRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBashRules
// This API is used to obtain the list of high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashRules(request *DescribeBashRulesRequest) (response *DescribeBashRulesResponse, err error) {
    return c.DescribeBashRulesWithContext(context.Background(), request)
}

// DescribeBashRules
// This API is used to obtain the list of high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBashRulesWithContext(ctx context.Context, request *DescribeBashRulesRequest) (response *DescribeBashRulesResponse, err error) {
    if request == nil {
        request = NewDescribeBashRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBashRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBashRules require credential")
    }

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

func NewDescribeBruteAttackListRequest() (request *DescribeBruteAttackListRequest) {
    request = &DescribeBruteAttackListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBruteAttackList")
    
    
    return
}

func NewDescribeBruteAttackListResponse() (response *DescribeBruteAttackListResponse) {
    response = &DescribeBruteAttackListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBruteAttackList
// This API is used to obtain the list of password cracking.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBruteAttackList(request *DescribeBruteAttackListRequest) (response *DescribeBruteAttackListResponse, err error) {
    return c.DescribeBruteAttackListWithContext(context.Background(), request)
}

// DescribeBruteAttackList
// This API is used to obtain the list of password cracking.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeBruteAttackListWithContext(ctx context.Context, request *DescribeBruteAttackListRequest) (response *DescribeBruteAttackListResponse, err error) {
    if request == nil {
        request = NewDescribeBruteAttackListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBruteAttackList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBruteAttackList require credential")
    }

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

func NewDescribeBruteAttackRulesRequest() (request *DescribeBruteAttackRulesRequest) {
    request = &DescribeBruteAttackRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeBruteAttackRules")
    
    
    return
}

func NewDescribeBruteAttackRulesResponse() (response *DescribeBruteAttackRulesResponse) {
    response = &DescribeBruteAttackRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeBruteAttackRules
// This API is used to obtain brute force cracking rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeBruteAttackRules(request *DescribeBruteAttackRulesRequest) (response *DescribeBruteAttackRulesResponse, err error) {
    return c.DescribeBruteAttackRulesWithContext(context.Background(), request)
}

// DescribeBruteAttackRules
// This API is used to obtain brute force cracking rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeBruteAttackRulesWithContext(ctx context.Context, request *DescribeBruteAttackRulesRequest) (response *DescribeBruteAttackRulesResponse, err error) {
    if request == nil {
        request = NewDescribeBruteAttackRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeBruteAttackRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeBruteAttackRules require credential")
    }

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

func NewDescribeCanFixVulMachineRequest() (request *DescribeCanFixVulMachineRequest) {
    request = &DescribeCanFixVulMachineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeCanFixVulMachine")
    
    
    return
}

func NewDescribeCanFixVulMachineResponse() (response *DescribeCanFixVulMachineResponse) {
    response = &DescribeCanFixVulMachineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeCanFixVulMachine
// This API is used to query the fixable host information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCanFixVulMachine(request *DescribeCanFixVulMachineRequest) (response *DescribeCanFixVulMachineResponse, err error) {
    return c.DescribeCanFixVulMachineWithContext(context.Background(), request)
}

// DescribeCanFixVulMachine
// This API is used to query the fixable host information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeCanFixVulMachineWithContext(ctx context.Context, request *DescribeCanFixVulMachineRequest) (response *DescribeCanFixVulMachineResponse, err error) {
    if request == nil {
        request = NewDescribeCanFixVulMachineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeCanFixVulMachine")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeCanFixVulMachine require credential")
    }

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

func NewDescribeCanNotSeparateMachineRequest() (request *DescribeCanNotSeparateMachineRequest) {
    request = &DescribeCanNotSeparateMachineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeCanNotSeparateMachine")
    
    
    return
}

func NewDescribeCanNotSeparateMachineResponse() (response *DescribeCanNotSeparateMachineResponse) {
    response = &DescribeCanNotSeparateMachineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeCanNotSeparateMachine
// This API is used to obtain hosts where Trojans cannot be isolated.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeCanNotSeparateMachine(request *DescribeCanNotSeparateMachineRequest) (response *DescribeCanNotSeparateMachineResponse, err error) {
    return c.DescribeCanNotSeparateMachineWithContext(context.Background(), request)
}

// DescribeCanNotSeparateMachine
// This API is used to obtain hosts where Trojans cannot be isolated.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeCanNotSeparateMachineWithContext(ctx context.Context, request *DescribeCanNotSeparateMachineRequest) (response *DescribeCanNotSeparateMachineResponse, err error) {
    if request == nil {
        request = NewDescribeCanNotSeparateMachineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeCanNotSeparateMachine")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeCanNotSeparateMachine require credential")
    }

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

func NewDescribeClientExceptionRequest() (request *DescribeClientExceptionRequest) {
    request = &DescribeClientExceptionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeClientException")
    
    
    return
}

func NewDescribeClientExceptionResponse() (response *DescribeClientExceptionResponse) {
    response = &DescribeClientExceptionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeClientException
// This API is used to obtain client exception events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeClientException(request *DescribeClientExceptionRequest) (response *DescribeClientExceptionResponse, err error) {
    return c.DescribeClientExceptionWithContext(context.Background(), request)
}

// DescribeClientException
// This API is used to obtain client exception events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeClientExceptionWithContext(ctx context.Context, request *DescribeClientExceptionRequest) (response *DescribeClientExceptionResponse, err error) {
    if request == nil {
        request = NewDescribeClientExceptionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeClientException")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeClientException require credential")
    }

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

func NewDescribeComponentStatisticsRequest() (request *DescribeComponentStatisticsRequest) {
    request = &DescribeComponentStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeComponentStatistics")
    
    
    return
}

func NewDescribeComponentStatisticsResponse() (response *DescribeComponentStatisticsResponse) {
    response = &DescribeComponentStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeComponentStatistics
// 接口已无效
//
// 
//
// This API is used to obtain the data of the component statistics list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeComponentStatistics(request *DescribeComponentStatisticsRequest) (response *DescribeComponentStatisticsResponse, err error) {
    return c.DescribeComponentStatisticsWithContext(context.Background(), request)
}

// DescribeComponentStatistics
// 接口已无效
//
// 
//
// This API is used to obtain the data of the component statistics list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeComponentStatisticsWithContext(ctx context.Context, request *DescribeComponentStatisticsRequest) (response *DescribeComponentStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeComponentStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeComponentStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeComponentStatistics require credential")
    }

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

func NewDescribeDefenceEventDetailRequest() (request *DescribeDefenceEventDetailRequest) {
    request = &DescribeDefenceEventDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeDefenceEventDetail")
    
    
    return
}

func NewDescribeDefenceEventDetailResponse() (response *DescribeDefenceEventDetailResponse) {
    response = &DescribeDefenceEventDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeDefenceEventDetail
// This API is used to obtain vulnerability defense event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeDefenceEventDetail(request *DescribeDefenceEventDetailRequest) (response *DescribeDefenceEventDetailResponse, err error) {
    return c.DescribeDefenceEventDetailWithContext(context.Background(), request)
}

// DescribeDefenceEventDetail
// This API is used to obtain vulnerability defense event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeDefenceEventDetailWithContext(ctx context.Context, request *DescribeDefenceEventDetailRequest) (response *DescribeDefenceEventDetailResponse, err error) {
    if request == nil {
        request = NewDescribeDefenceEventDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeDefenceEventDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeDefenceEventDetail require credential")
    }

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

func NewDescribeDirectConnectInstallCommandRequest() (request *DescribeDirectConnectInstallCommandRequest) {
    request = &DescribeDirectConnectInstallCommandRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeDirectConnectInstallCommand")
    
    
    return
}

func NewDescribeDirectConnectInstallCommandResponse() (response *DescribeDirectConnectInstallCommandResponse) {
    response = &DescribeDirectConnectInstallCommandResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeDirectConnectInstallCommand
// This API is used to obtain DC agent installation command, including the token.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeDirectConnectInstallCommand(request *DescribeDirectConnectInstallCommandRequest) (response *DescribeDirectConnectInstallCommandResponse, err error) {
    return c.DescribeDirectConnectInstallCommandWithContext(context.Background(), request)
}

// DescribeDirectConnectInstallCommand
// This API is used to obtain DC agent installation command, including the token.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeDirectConnectInstallCommandWithContext(ctx context.Context, request *DescribeDirectConnectInstallCommandRequest) (response *DescribeDirectConnectInstallCommandResponse, err error) {
    if request == nil {
        request = NewDescribeDirectConnectInstallCommandRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeDirectConnectInstallCommand")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeDirectConnectInstallCommand require credential")
    }

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

func NewDescribeESAggregationsRequest() (request *DescribeESAggregationsRequest) {
    request = &DescribeESAggregationsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeESAggregations")
    
    
    return
}

func NewDescribeESAggregationsResponse() (response *DescribeESAggregationsResponse) {
    response = &DescribeESAggregationsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeESAggregations
// This API is used to obtain the aggregation result of the ES field.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeESAggregations(request *DescribeESAggregationsRequest) (response *DescribeESAggregationsResponse, err error) {
    return c.DescribeESAggregationsWithContext(context.Background(), request)
}

// DescribeESAggregations
// This API is used to obtain the aggregation result of the ES field.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeESAggregationsWithContext(ctx context.Context, request *DescribeESAggregationsRequest) (response *DescribeESAggregationsResponse, err error) {
    if request == nil {
        request = NewDescribeESAggregationsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeESAggregations")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeESAggregations require credential")
    }

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

func NewDescribeEmergencyResponseListRequest() (request *DescribeEmergencyResponseListRequest) {
    request = &DescribeEmergencyResponseListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeEmergencyResponseList")
    
    
    return
}

func NewDescribeEmergencyResponseListResponse() (response *DescribeEmergencyResponseListResponse) {
    response = &DescribeEmergencyResponseListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeEmergencyResponseList
// This API is used to obtain the emergency response list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEmergencyResponseList(request *DescribeEmergencyResponseListRequest) (response *DescribeEmergencyResponseListResponse, err error) {
    return c.DescribeEmergencyResponseListWithContext(context.Background(), request)
}

// DescribeEmergencyResponseList
// This API is used to obtain the emergency response list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEmergencyResponseListWithContext(ctx context.Context, request *DescribeEmergencyResponseListRequest) (response *DescribeEmergencyResponseListResponse, err error) {
    if request == nil {
        request = NewDescribeEmergencyResponseListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeEmergencyResponseList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeEmergencyResponseList require credential")
    }

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

func NewDescribeEmergencyVulListRequest() (request *DescribeEmergencyVulListRequest) {
    request = &DescribeEmergencyVulListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeEmergencyVulList")
    
    
    return
}

func NewDescribeEmergencyVulListResponse() (response *DescribeEmergencyVulListResponse) {
    response = &DescribeEmergencyVulListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeEmergencyVulList
// This API is used to obtain the list of emergency vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEmergencyVulList(request *DescribeEmergencyVulListRequest) (response *DescribeEmergencyVulListResponse, err error) {
    return c.DescribeEmergencyVulListWithContext(context.Background(), request)
}

// DescribeEmergencyVulList
// This API is used to obtain the list of emergency vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEmergencyVulListWithContext(ctx context.Context, request *DescribeEmergencyVulListRequest) (response *DescribeEmergencyVulListResponse, err error) {
    if request == nil {
        request = NewDescribeEmergencyVulListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeEmergencyVulList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeEmergencyVulList require credential")
    }

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

func NewDescribeEventByTableRequest() (request *DescribeEventByTableRequest) {
    request = &DescribeEventByTableRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeEventByTable")
    
    
    return
}

func NewDescribeEventByTableResponse() (response *DescribeEventByTableResponse) {
    response = &DescribeEventByTableResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeEventByTable
// This API is used to query alarm event details based on event table names and IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEventByTable(request *DescribeEventByTableRequest) (response *DescribeEventByTableResponse, err error) {
    return c.DescribeEventByTableWithContext(context.Background(), request)
}

// DescribeEventByTable
// This API is used to query alarm event details based on event table names and IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeEventByTableWithContext(ctx context.Context, request *DescribeEventByTableRequest) (response *DescribeEventByTableResponse, err error) {
    if request == nil {
        request = NewDescribeEventByTableRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeEventByTable")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeEventByTable require credential")
    }

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

func NewDescribeExpertServiceListRequest() (request *DescribeExpertServiceListRequest) {
    request = &DescribeExpertServiceListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeExpertServiceList")
    
    
    return
}

func NewDescribeExpertServiceListResponse() (response *DescribeExpertServiceListResponse) {
    response = &DescribeExpertServiceListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeExpertServiceList
// This API is used to obtain the security manager list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExpertServiceList(request *DescribeExpertServiceListRequest) (response *DescribeExpertServiceListResponse, err error) {
    return c.DescribeExpertServiceListWithContext(context.Background(), request)
}

// DescribeExpertServiceList
// This API is used to obtain the security manager list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExpertServiceListWithContext(ctx context.Context, request *DescribeExpertServiceListRequest) (response *DescribeExpertServiceListResponse, err error) {
    if request == nil {
        request = NewDescribeExpertServiceListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeExpertServiceList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeExpertServiceList require credential")
    }

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

func NewDescribeExpertServiceOrderListRequest() (request *DescribeExpertServiceOrderListRequest) {
    request = &DescribeExpertServiceOrderListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeExpertServiceOrderList")
    
    
    return
}

func NewDescribeExpertServiceOrderListResponse() (response *DescribeExpertServiceOrderListResponse) {
    response = &DescribeExpertServiceOrderListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeExpertServiceOrderList
// This API is used to obtain the expert service order list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExpertServiceOrderList(request *DescribeExpertServiceOrderListRequest) (response *DescribeExpertServiceOrderListResponse, err error) {
    return c.DescribeExpertServiceOrderListWithContext(context.Background(), request)
}

// DescribeExpertServiceOrderList
// This API is used to obtain the expert service order list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExpertServiceOrderListWithContext(ctx context.Context, request *DescribeExpertServiceOrderListRequest) (response *DescribeExpertServiceOrderListResponse, err error) {
    if request == nil {
        request = NewDescribeExpertServiceOrderListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeExpertServiceOrderList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeExpertServiceOrderList require credential")
    }

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

func NewDescribeExportMachinesRequest() (request *DescribeExportMachinesRequest) {
    request = &DescribeExportMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeExportMachines")
    
    
    return
}

func NewDescribeExportMachinesResponse() (response *DescribeExportMachinesResponse) {
    response = &DescribeExportMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeExportMachines
// This API is used to export the list of hosts in a specific region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExportMachines(request *DescribeExportMachinesRequest) (response *DescribeExportMachinesResponse, err error) {
    return c.DescribeExportMachinesWithContext(context.Background(), request)
}

// DescribeExportMachines
// This API is used to export the list of hosts in a specific region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeExportMachinesWithContext(ctx context.Context, request *DescribeExportMachinesRequest) (response *DescribeExportMachinesResponse, err error) {
    if request == nil {
        request = NewDescribeExportMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeExportMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeExportMachines require credential")
    }

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

func NewDescribeFastAnalysisRequest() (request *DescribeFastAnalysisRequest) {
    request = &DescribeFastAnalysisRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFastAnalysis")
    
    
    return
}

func NewDescribeFastAnalysisResponse() (response *DescribeFastAnalysisResponse) {
    response = &DescribeFastAnalysisResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFastAnalysis
// This API is used to quickly analyze and count logs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFastAnalysis(request *DescribeFastAnalysisRequest) (response *DescribeFastAnalysisResponse, err error) {
    return c.DescribeFastAnalysisWithContext(context.Background(), request)
}

// DescribeFastAnalysis
// This API is used to quickly analyze and count logs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFastAnalysisWithContext(ctx context.Context, request *DescribeFastAnalysisRequest) (response *DescribeFastAnalysisResponse, err error) {
    if request == nil {
        request = NewDescribeFastAnalysisRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFastAnalysis")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFastAnalysis require credential")
    }

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

func NewDescribeFileTamperEventRuleInfoRequest() (request *DescribeFileTamperEventRuleInfoRequest) {
    request = &DescribeFileTamperEventRuleInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFileTamperEventRuleInfo")
    
    
    return
}

func NewDescribeFileTamperEventRuleInfoResponse() (response *DescribeFileTamperEventRuleInfoResponse) {
    response = &DescribeFileTamperEventRuleInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFileTamperEventRuleInfo
// This API is used to view the rule details API when an event occurs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperEventRuleInfo(request *DescribeFileTamperEventRuleInfoRequest) (response *DescribeFileTamperEventRuleInfoResponse, err error) {
    return c.DescribeFileTamperEventRuleInfoWithContext(context.Background(), request)
}

// DescribeFileTamperEventRuleInfo
// This API is used to view the rule details API when an event occurs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperEventRuleInfoWithContext(ctx context.Context, request *DescribeFileTamperEventRuleInfoRequest) (response *DescribeFileTamperEventRuleInfoResponse, err error) {
    if request == nil {
        request = NewDescribeFileTamperEventRuleInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFileTamperEventRuleInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFileTamperEventRuleInfo require credential")
    }

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

func NewDescribeFileTamperEventsRequest() (request *DescribeFileTamperEventsRequest) {
    request = &DescribeFileTamperEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFileTamperEvents")
    
    
    return
}

func NewDescribeFileTamperEventsResponse() (response *DescribeFileTamperEventsResponse) {
    response = &DescribeFileTamperEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFileTamperEvents
// This API is used to obtain the list of core file monitoring events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFileTamperEvents(request *DescribeFileTamperEventsRequest) (response *DescribeFileTamperEventsResponse, err error) {
    return c.DescribeFileTamperEventsWithContext(context.Background(), request)
}

// DescribeFileTamperEvents
// This API is used to obtain the list of core file monitoring events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFileTamperEventsWithContext(ctx context.Context, request *DescribeFileTamperEventsRequest) (response *DescribeFileTamperEventsResponse, err error) {
    if request == nil {
        request = NewDescribeFileTamperEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFileTamperEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFileTamperEvents require credential")
    }

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

func NewDescribeFileTamperRuleCountRequest() (request *DescribeFileTamperRuleCountRequest) {
    request = &DescribeFileTamperRuleCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFileTamperRuleCount")
    
    
    return
}

func NewDescribeFileTamperRuleCountResponse() (response *DescribeFileTamperRuleCountResponse) {
    response = &DescribeFileTamperRuleCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFileTamperRuleCount
// This API is used to query the number of rules for monitoring files associated with a host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperRuleCount(request *DescribeFileTamperRuleCountRequest) (response *DescribeFileTamperRuleCountResponse, err error) {
    return c.DescribeFileTamperRuleCountWithContext(context.Background(), request)
}

// DescribeFileTamperRuleCount
// This API is used to query the number of rules for monitoring files associated with a host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperRuleCountWithContext(ctx context.Context, request *DescribeFileTamperRuleCountRequest) (response *DescribeFileTamperRuleCountResponse, err error) {
    if request == nil {
        request = NewDescribeFileTamperRuleCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFileTamperRuleCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFileTamperRuleCount require credential")
    }

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

func NewDescribeFileTamperRuleInfoRequest() (request *DescribeFileTamperRuleInfoRequest) {
    request = &DescribeFileTamperRuleInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFileTamperRuleInfo")
    
    
    return
}

func NewDescribeFileTamperRuleInfoResponse() (response *DescribeFileTamperRuleInfoResponse) {
    response = &DescribeFileTamperRuleInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFileTamperRuleInfo
// This API is used to query details of a monitoring rule.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperRuleInfo(request *DescribeFileTamperRuleInfoRequest) (response *DescribeFileTamperRuleInfoResponse, err error) {
    return c.DescribeFileTamperRuleInfoWithContext(context.Background(), request)
}

// DescribeFileTamperRuleInfo
// This API is used to query details of a monitoring rule.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeFileTamperRuleInfoWithContext(ctx context.Context, request *DescribeFileTamperRuleInfoRequest) (response *DescribeFileTamperRuleInfoResponse, err error) {
    if request == nil {
        request = NewDescribeFileTamperRuleInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFileTamperRuleInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFileTamperRuleInfo require credential")
    }

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

func NewDescribeFileTamperRulesRequest() (request *DescribeFileTamperRulesRequest) {
    request = &DescribeFileTamperRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeFileTamperRules")
    
    
    return
}

func NewDescribeFileTamperRulesResponse() (response *DescribeFileTamperRulesResponse) {
    response = &DescribeFileTamperRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeFileTamperRules
// This API is used to obtain the list of core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFileTamperRules(request *DescribeFileTamperRulesRequest) (response *DescribeFileTamperRulesResponse, err error) {
    return c.DescribeFileTamperRulesWithContext(context.Background(), request)
}

// DescribeFileTamperRules
// This API is used to obtain the list of core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeFileTamperRulesWithContext(ctx context.Context, request *DescribeFileTamperRulesRequest) (response *DescribeFileTamperRulesResponse, err error) {
    if request == nil {
        request = NewDescribeFileTamperRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeFileTamperRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeFileTamperRules require credential")
    }

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

func NewDescribeGeneralStatRequest() (request *DescribeGeneralStatRequest) {
    request = &DescribeGeneralStatRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeGeneralStat")
    
    
    return
}

func NewDescribeGeneralStatResponse() (response *DescribeGeneralStatResponse) {
    response = &DescribeGeneralStatResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeGeneralStat
// This API is used to obtain the statistics data of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeGeneralStat(request *DescribeGeneralStatRequest) (response *DescribeGeneralStatResponse, err error) {
    return c.DescribeGeneralStatWithContext(context.Background(), request)
}

// DescribeGeneralStat
// This API is used to obtain the statistics data of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeGeneralStatWithContext(ctx context.Context, request *DescribeGeneralStatRequest) (response *DescribeGeneralStatResponse, err error) {
    if request == nil {
        request = NewDescribeGeneralStatRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeGeneralStat")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeGeneralStat require credential")
    }

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

func NewDescribeHistoryAccountsRequest() (request *DescribeHistoryAccountsRequest) {
    request = &DescribeHistoryAccountsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeHistoryAccounts")
    
    
    return
}

func NewDescribeHistoryAccountsResponse() (response *DescribeHistoryAccountsResponse) {
    response = &DescribeHistoryAccountsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeHistoryAccounts
// This API is used to obtain the data of the account change history list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHistoryAccounts(request *DescribeHistoryAccountsRequest) (response *DescribeHistoryAccountsResponse, err error) {
    return c.DescribeHistoryAccountsWithContext(context.Background(), request)
}

// DescribeHistoryAccounts
// This API is used to obtain the data of the account change history list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHistoryAccountsWithContext(ctx context.Context, request *DescribeHistoryAccountsRequest) (response *DescribeHistoryAccountsResponse, err error) {
    if request == nil {
        request = NewDescribeHistoryAccountsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeHistoryAccounts")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeHistoryAccounts require credential")
    }

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

func NewDescribeHistoryServiceRequest() (request *DescribeHistoryServiceRequest) {
    request = &DescribeHistoryServiceRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeHistoryService")
    
    
    return
}

func NewDescribeHistoryServiceResponse() (response *DescribeHistoryServiceResponse) {
    response = &DescribeHistoryServiceResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeHistoryService
// This API is used to query the log retrieval service information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeHistoryService(request *DescribeHistoryServiceRequest) (response *DescribeHistoryServiceResponse, err error) {
    return c.DescribeHistoryServiceWithContext(context.Background(), request)
}

// DescribeHistoryService
// This API is used to query the log retrieval service information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeHistoryServiceWithContext(ctx context.Context, request *DescribeHistoryServiceRequest) (response *DescribeHistoryServiceResponse, err error) {
    if request == nil {
        request = NewDescribeHistoryServiceRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeHistoryService")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeHistoryService require credential")
    }

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

func NewDescribeHostInfoRequest() (request *DescribeHostInfoRequest) {
    request = &DescribeHostInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeHostInfo")
    
    
    return
}

func NewDescribeHostInfoResponse() (response *DescribeHostInfoResponse) {
    response = &DescribeHostInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeHostInfo
// This API is used to query the host and tag information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHostInfo(request *DescribeHostInfoRequest) (response *DescribeHostInfoResponse, err error) {
    return c.DescribeHostInfoWithContext(context.Background(), request)
}

// DescribeHostInfo
// This API is used to query the host and tag information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHostInfoWithContext(ctx context.Context, request *DescribeHostInfoRequest) (response *DescribeHostInfoResponse, err error) {
    if request == nil {
        request = NewDescribeHostInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeHostInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeHostInfo require credential")
    }

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

func NewDescribeHostLoginListRequest() (request *DescribeHostLoginListRequest) {
    request = &DescribeHostLoginListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeHostLoginList")
    
    
    return
}

func NewDescribeHostLoginListResponse() (response *DescribeHostLoginListResponse) {
    response = &DescribeHostLoginListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeHostLoginList
// This API is used to retrieve the log-in audit list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHostLoginList(request *DescribeHostLoginListRequest) (response *DescribeHostLoginListResponse, err error) {
    return c.DescribeHostLoginListWithContext(context.Background(), request)
}

// DescribeHostLoginList
// This API is used to retrieve the log-in audit list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeHostLoginListWithContext(ctx context.Context, request *DescribeHostLoginListRequest) (response *DescribeHostLoginListResponse, err error) {
    if request == nil {
        request = NewDescribeHostLoginListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeHostLoginList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeHostLoginList require credential")
    }

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

func NewDescribeHotVulTopRequest() (request *DescribeHotVulTopRequest) {
    request = &DescribeHotVulTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeHotVulTop")
    
    
    return
}

func NewDescribeHotVulTopResponse() (response *DescribeHotVulTopResponse) {
    response = &DescribeHotVulTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeHotVulTop
// This API is used to obtain hot spot vulnerabilities across the entire network.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeHotVulTop(request *DescribeHotVulTopRequest) (response *DescribeHotVulTopResponse, err error) {
    return c.DescribeHotVulTopWithContext(context.Background(), request)
}

// DescribeHotVulTop
// This API is used to obtain hot spot vulnerabilities across the entire network.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeHotVulTopWithContext(ctx context.Context, request *DescribeHotVulTopRequest) (response *DescribeHotVulTopResponse, err error) {
    if request == nil {
        request = NewDescribeHotVulTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeHotVulTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeHotVulTop require credential")
    }

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

func NewDescribeIgnoreBaselineRuleRequest() (request *DescribeIgnoreBaselineRuleRequest) {
    request = &DescribeIgnoreBaselineRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeIgnoreBaselineRule")
    
    
    return
}

func NewDescribeIgnoreBaselineRuleResponse() (response *DescribeIgnoreBaselineRuleResponse) {
    response = &DescribeIgnoreBaselineRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeIgnoreBaselineRule
// This API is used to query the information of ignored inspection items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeIgnoreBaselineRule(request *DescribeIgnoreBaselineRuleRequest) (response *DescribeIgnoreBaselineRuleResponse, err error) {
    return c.DescribeIgnoreBaselineRuleWithContext(context.Background(), request)
}

// DescribeIgnoreBaselineRule
// This API is used to query the information of ignored inspection items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeIgnoreBaselineRuleWithContext(ctx context.Context, request *DescribeIgnoreBaselineRuleRequest) (response *DescribeIgnoreBaselineRuleResponse, err error) {
    if request == nil {
        request = NewDescribeIgnoreBaselineRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeIgnoreBaselineRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeIgnoreBaselineRule require credential")
    }

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

func NewDescribeIgnoreHostAndItemConfigRequest() (request *DescribeIgnoreHostAndItemConfigRequest) {
    request = &DescribeIgnoreHostAndItemConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeIgnoreHostAndItemConfig")
    
    
    return
}

func NewDescribeIgnoreHostAndItemConfigResponse() (response *DescribeIgnoreHostAndItemConfigResponse) {
    response = &DescribeIgnoreHostAndItemConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeIgnoreHostAndItemConfig
// This API is used to obtain the information of affected inspection items and hosts ignored with one click.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeIgnoreHostAndItemConfig(request *DescribeIgnoreHostAndItemConfigRequest) (response *DescribeIgnoreHostAndItemConfigResponse, err error) {
    return c.DescribeIgnoreHostAndItemConfigWithContext(context.Background(), request)
}

// DescribeIgnoreHostAndItemConfig
// This API is used to obtain the information of affected inspection items and hosts ignored with one click.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeIgnoreHostAndItemConfigWithContext(ctx context.Context, request *DescribeIgnoreHostAndItemConfigRequest) (response *DescribeIgnoreHostAndItemConfigResponse, err error) {
    if request == nil {
        request = NewDescribeIgnoreHostAndItemConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeIgnoreHostAndItemConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeIgnoreHostAndItemConfig require credential")
    }

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

func NewDescribeIgnoreRuleEffectHostListRequest() (request *DescribeIgnoreRuleEffectHostListRequest) {
    request = &DescribeIgnoreRuleEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeIgnoreRuleEffectHostList")
    
    
    return
}

func NewDescribeIgnoreRuleEffectHostListResponse() (response *DescribeIgnoreRuleEffectHostListResponse) {
    response = &DescribeIgnoreRuleEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeIgnoreRuleEffectHostList
// This API is used to query the information on the list of hosts affected by ignored detection items based on detection item IDs and filter criteria.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeIgnoreRuleEffectHostList(request *DescribeIgnoreRuleEffectHostListRequest) (response *DescribeIgnoreRuleEffectHostListResponse, err error) {
    return c.DescribeIgnoreRuleEffectHostListWithContext(context.Background(), request)
}

// DescribeIgnoreRuleEffectHostList
// This API is used to query the information on the list of hosts affected by ignored detection items based on detection item IDs and filter criteria.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeIgnoreRuleEffectHostListWithContext(ctx context.Context, request *DescribeIgnoreRuleEffectHostListRequest) (response *DescribeIgnoreRuleEffectHostListResponse, err error) {
    if request == nil {
        request = NewDescribeIgnoreRuleEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeIgnoreRuleEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeIgnoreRuleEffectHostList require credential")
    }

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

func NewDescribeIndexListRequest() (request *DescribeIndexListRequest) {
    request = &DescribeIndexListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeIndexList")
    
    
    return
}

func NewDescribeIndexListResponse() (response *DescribeIndexListResponse) {
    response = &DescribeIndexListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeIndexList
// 接口已废弃
//
// 
//
// This API is used to obtain the index list.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeIndexList(request *DescribeIndexListRequest) (response *DescribeIndexListResponse, err error) {
    return c.DescribeIndexListWithContext(context.Background(), request)
}

// DescribeIndexList
// 接口已废弃
//
// 
//
// This API is used to obtain the index list.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeIndexListWithContext(ctx context.Context, request *DescribeIndexListRequest) (response *DescribeIndexListResponse, err error) {
    if request == nil {
        request = NewDescribeIndexListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeIndexList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeIndexList require credential")
    }

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

func NewDescribeJavaMemShellInfoRequest() (request *DescribeJavaMemShellInfoRequest) {
    request = &DescribeJavaMemShellInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeJavaMemShellInfo")
    
    
    return
}

func NewDescribeJavaMemShellInfoResponse() (response *DescribeJavaMemShellInfoResponse) {
    response = &DescribeJavaMemShellInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeJavaMemShellInfo
// This API is used to query Java webshell event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeJavaMemShellInfo(request *DescribeJavaMemShellInfoRequest) (response *DescribeJavaMemShellInfoResponse, err error) {
    return c.DescribeJavaMemShellInfoWithContext(context.Background(), request)
}

// DescribeJavaMemShellInfo
// This API is used to query Java webshell event details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeJavaMemShellInfoWithContext(ctx context.Context, request *DescribeJavaMemShellInfoRequest) (response *DescribeJavaMemShellInfoResponse, err error) {
    if request == nil {
        request = NewDescribeJavaMemShellInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeJavaMemShellInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeJavaMemShellInfo require credential")
    }

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

func NewDescribeJavaMemShellListRequest() (request *DescribeJavaMemShellListRequest) {
    request = &DescribeJavaMemShellListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeJavaMemShellList")
    
    
    return
}

func NewDescribeJavaMemShellListResponse() (response *DescribeJavaMemShellListResponse) {
    response = &DescribeJavaMemShellListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeJavaMemShellList
// This API is used to query the list of Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellList(request *DescribeJavaMemShellListRequest) (response *DescribeJavaMemShellListResponse, err error) {
    return c.DescribeJavaMemShellListWithContext(context.Background(), request)
}

// DescribeJavaMemShellList
// This API is used to query the list of Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellListWithContext(ctx context.Context, request *DescribeJavaMemShellListRequest) (response *DescribeJavaMemShellListResponse, err error) {
    if request == nil {
        request = NewDescribeJavaMemShellListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeJavaMemShellList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeJavaMemShellList require credential")
    }

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

func NewDescribeJavaMemShellPluginInfoRequest() (request *DescribeJavaMemShellPluginInfoRequest) {
    request = &DescribeJavaMemShellPluginInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeJavaMemShellPluginInfo")
    
    
    return
}

func NewDescribeJavaMemShellPluginInfoResponse() (response *DescribeJavaMemShellPluginInfoResponse) {
    response = &DescribeJavaMemShellPluginInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeJavaMemShellPluginInfo
// This API is used to query the Java webshell plugin information of the given host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellPluginInfo(request *DescribeJavaMemShellPluginInfoRequest) (response *DescribeJavaMemShellPluginInfoResponse, err error) {
    return c.DescribeJavaMemShellPluginInfoWithContext(context.Background(), request)
}

// DescribeJavaMemShellPluginInfo
// This API is used to query the Java webshell plugin information of the given host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellPluginInfoWithContext(ctx context.Context, request *DescribeJavaMemShellPluginInfoRequest) (response *DescribeJavaMemShellPluginInfoResponse, err error) {
    if request == nil {
        request = NewDescribeJavaMemShellPluginInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeJavaMemShellPluginInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeJavaMemShellPluginInfo require credential")
    }

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

func NewDescribeJavaMemShellPluginListRequest() (request *DescribeJavaMemShellPluginListRequest) {
    request = &DescribeJavaMemShellPluginListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeJavaMemShellPluginList")
    
    
    return
}

func NewDescribeJavaMemShellPluginListResponse() (response *DescribeJavaMemShellPluginListResponse) {
    response = &DescribeJavaMemShellPluginListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeJavaMemShellPluginList
// This API is used to query the Java webshell plugin list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellPluginList(request *DescribeJavaMemShellPluginListRequest) (response *DescribeJavaMemShellPluginListResponse, err error) {
    return c.DescribeJavaMemShellPluginListWithContext(context.Background(), request)
}

// DescribeJavaMemShellPluginList
// This API is used to query the Java webshell plugin list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeJavaMemShellPluginListWithContext(ctx context.Context, request *DescribeJavaMemShellPluginListRequest) (response *DescribeJavaMemShellPluginListResponse, err error) {
    if request == nil {
        request = NewDescribeJavaMemShellPluginListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeJavaMemShellPluginList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeJavaMemShellPluginList require credential")
    }

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

func NewDescribeLicenseRequest() (request *DescribeLicenseRequest) {
    request = &DescribeLicenseRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicense")
    
    
    return
}

func NewDescribeLicenseResponse() (response *DescribeLicenseResponse) {
    response = &DescribeLicenseResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicense
// This API is used to query the authorization information.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicense(request *DescribeLicenseRequest) (response *DescribeLicenseResponse, err error) {
    return c.DescribeLicenseWithContext(context.Background(), request)
}

// DescribeLicense
// This API is used to query the authorization information.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseWithContext(ctx context.Context, request *DescribeLicenseRequest) (response *DescribeLicenseResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicense")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicense require credential")
    }

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

func NewDescribeLicenseBindListRequest() (request *DescribeLicenseBindListRequest) {
    request = &DescribeLicenseBindListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicenseBindList")
    
    
    return
}

func NewDescribeLicenseBindListResponse() (response *DescribeLicenseBindListResponse) {
    response = &DescribeLicenseBindListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicenseBindList
// This API is used to obtain the list of authorized machines bound to an authorization under the Settings Center-Authorization Management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseBindList(request *DescribeLicenseBindListRequest) (response *DescribeLicenseBindListResponse, err error) {
    return c.DescribeLicenseBindListWithContext(context.Background(), request)
}

// DescribeLicenseBindList
// This API is used to obtain the list of authorized machines bound to an authorization under the Settings Center-Authorization Management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseBindListWithContext(ctx context.Context, request *DescribeLicenseBindListRequest) (response *DescribeLicenseBindListResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseBindListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicenseBindList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicenseBindList require credential")
    }

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

func NewDescribeLicenseBindScheduleRequest() (request *DescribeLicenseBindScheduleRequest) {
    request = &DescribeLicenseBindScheduleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicenseBindSchedule")
    
    
    return
}

func NewDescribeLicenseBindScheduleResponse() (response *DescribeLicenseBindScheduleResponse) {
    response = &DescribeLicenseBindScheduleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicenseBindSchedule
// This API is used to query the binding task progress of the authorization.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseBindSchedule(request *DescribeLicenseBindScheduleRequest) (response *DescribeLicenseBindScheduleResponse, err error) {
    return c.DescribeLicenseBindScheduleWithContext(context.Background(), request)
}

// DescribeLicenseBindSchedule
// This API is used to query the binding task progress of the authorization.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseBindScheduleWithContext(ctx context.Context, request *DescribeLicenseBindScheduleRequest) (response *DescribeLicenseBindScheduleResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseBindScheduleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicenseBindSchedule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicenseBindSchedule require credential")
    }

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

func NewDescribeLicenseGeneralRequest() (request *DescribeLicenseGeneralRequest) {
    request = &DescribeLicenseGeneralRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicenseGeneral")
    
    
    return
}

func NewDescribeLicenseGeneralResponse() (response *DescribeLicenseGeneralResponse) {
    response = &DescribeLicenseGeneralResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicenseGeneral
// This API is used to obtain the authorization overview information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLicenseGeneral(request *DescribeLicenseGeneralRequest) (response *DescribeLicenseGeneralResponse, err error) {
    return c.DescribeLicenseGeneralWithContext(context.Background(), request)
}

// DescribeLicenseGeneral
// This API is used to obtain the authorization overview information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLicenseGeneralWithContext(ctx context.Context, request *DescribeLicenseGeneralRequest) (response *DescribeLicenseGeneralResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseGeneralRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicenseGeneral")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicenseGeneral require credential")
    }

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

func NewDescribeLicenseListRequest() (request *DescribeLicenseListRequest) {
    request = &DescribeLicenseListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicenseList")
    
    
    return
}

func NewDescribeLicenseListResponse() (response *DescribeLicenseListResponse) {
    response = &DescribeLicenseListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicenseList
// This API is used to obtain all authorization orders of a user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeLicenseList(request *DescribeLicenseListRequest) (response *DescribeLicenseListResponse, err error) {
    return c.DescribeLicenseListWithContext(context.Background(), request)
}

// DescribeLicenseList
// This API is used to obtain all authorization orders of a user.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeLicenseListWithContext(ctx context.Context, request *DescribeLicenseListRequest) (response *DescribeLicenseListResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicenseList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicenseList require credential")
    }

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

func NewDescribeLicenseWhiteConfigRequest() (request *DescribeLicenseWhiteConfigRequest) {
    request = &DescribeLicenseWhiteConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLicenseWhiteConfig")
    
    
    return
}

func NewDescribeLicenseWhiteConfigResponse() (response *DescribeLicenseWhiteConfigResponse) {
    response = &DescribeLicenseWhiteConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLicenseWhiteConfig
// This API is used to query the available configurations for authorization allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseWhiteConfig(request *DescribeLicenseWhiteConfigRequest) (response *DescribeLicenseWhiteConfigResponse, err error) {
    return c.DescribeLicenseWhiteConfigWithContext(context.Background(), request)
}

// DescribeLicenseWhiteConfig
// This API is used to query the available configurations for authorization allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLicenseWhiteConfigWithContext(ctx context.Context, request *DescribeLicenseWhiteConfigRequest) (response *DescribeLicenseWhiteConfigResponse, err error) {
    if request == nil {
        request = NewDescribeLicenseWhiteConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLicenseWhiteConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLicenseWhiteConfig require credential")
    }

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

func NewDescribeLogDeliveryKafkaOptionsRequest() (request *DescribeLogDeliveryKafkaOptionsRequest) {
    request = &DescribeLogDeliveryKafkaOptionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogDeliveryKafkaOptions")
    
    
    return
}

func NewDescribeLogDeliveryKafkaOptionsResponse() (response *DescribeLogDeliveryKafkaOptionsResponse) {
    response = &DescribeLogDeliveryKafkaOptionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogDeliveryKafkaOptions
// This API is used to query the list of logs available for shipping to Kafka.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogDeliveryKafkaOptions(request *DescribeLogDeliveryKafkaOptionsRequest) (response *DescribeLogDeliveryKafkaOptionsResponse, err error) {
    return c.DescribeLogDeliveryKafkaOptionsWithContext(context.Background(), request)
}

// DescribeLogDeliveryKafkaOptions
// This API is used to query the list of logs available for shipping to Kafka.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogDeliveryKafkaOptionsWithContext(ctx context.Context, request *DescribeLogDeliveryKafkaOptionsRequest) (response *DescribeLogDeliveryKafkaOptionsResponse, err error) {
    if request == nil {
        request = NewDescribeLogDeliveryKafkaOptionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogDeliveryKafkaOptions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogDeliveryKafkaOptions require credential")
    }

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

func NewDescribeLogExportsRequest() (request *DescribeLogExportsRequest) {
    request = &DescribeLogExportsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogExports")
    
    
    return
}

func NewDescribeLogExportsResponse() (response *DescribeLogExportsResponse) {
    response = &DescribeLogExportsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogExports
// This API is used to obtain the list of log download tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogExports(request *DescribeLogExportsRequest) (response *DescribeLogExportsResponse, err error) {
    return c.DescribeLogExportsWithContext(context.Background(), request)
}

// DescribeLogExports
// This API is used to obtain the list of log download tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogExportsWithContext(ctx context.Context, request *DescribeLogExportsRequest) (response *DescribeLogExportsResponse, err error) {
    if request == nil {
        request = NewDescribeLogExportsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogExports")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogExports require credential")
    }

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

func NewDescribeLogHistogramRequest() (request *DescribeLogHistogramRequest) {
    request = &DescribeLogHistogramRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogHistogram")
    
    
    return
}

func NewDescribeLogHistogramResponse() (response *DescribeLogHistogramResponse) {
    response = &DescribeLogHistogramResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogHistogram
// This API is used to obtain the log histogram information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogHistogram(request *DescribeLogHistogramRequest) (response *DescribeLogHistogramResponse, err error) {
    return c.DescribeLogHistogramWithContext(context.Background(), request)
}

// DescribeLogHistogram
// This API is used to obtain the log histogram information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogHistogramWithContext(ctx context.Context, request *DescribeLogHistogramRequest) (response *DescribeLogHistogramResponse, err error) {
    if request == nil {
        request = NewDescribeLogHistogramRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogHistogram")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogHistogram require credential")
    }

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

func NewDescribeLogIndexRequest() (request *DescribeLogIndexRequest) {
    request = &DescribeLogIndexRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogIndex")
    
    
    return
}

func NewDescribeLogIndexResponse() (response *DescribeLogIndexResponse) {
    response = &DescribeLogIndexResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogIndex
// This API is used to query the index.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogIndex(request *DescribeLogIndexRequest) (response *DescribeLogIndexResponse, err error) {
    return c.DescribeLogIndexWithContext(context.Background(), request)
}

// DescribeLogIndex
// This API is used to query the index.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogIndexWithContext(ctx context.Context, request *DescribeLogIndexRequest) (response *DescribeLogIndexResponse, err error) {
    if request == nil {
        request = NewDescribeLogIndexRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogIndex")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogIndex require credential")
    }

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

func NewDescribeLogKafkaDeliverInfoRequest() (request *DescribeLogKafkaDeliverInfoRequest) {
    request = &DescribeLogKafkaDeliverInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogKafkaDeliverInfo")
    
    
    return
}

func NewDescribeLogKafkaDeliverInfoResponse() (response *DescribeLogKafkaDeliverInfoResponse) {
    response = &DescribeLogKafkaDeliverInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogKafkaDeliverInfo
// This API is used to obtain the information of Kafka shipping.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogKafkaDeliverInfo(request *DescribeLogKafkaDeliverInfoRequest) (response *DescribeLogKafkaDeliverInfoResponse, err error) {
    return c.DescribeLogKafkaDeliverInfoWithContext(context.Background(), request)
}

// DescribeLogKafkaDeliverInfo
// This API is used to obtain the information of Kafka shipping.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogKafkaDeliverInfoWithContext(ctx context.Context, request *DescribeLogKafkaDeliverInfoRequest) (response *DescribeLogKafkaDeliverInfoResponse, err error) {
    if request == nil {
        request = NewDescribeLogKafkaDeliverInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogKafkaDeliverInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogKafkaDeliverInfo require credential")
    }

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

func NewDescribeLogStorageConfigRequest() (request *DescribeLogStorageConfigRequest) {
    request = &DescribeLogStorageConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogStorageConfig")
    
    
    return
}

func NewDescribeLogStorageConfigResponse() (response *DescribeLogStorageConfigResponse) {
    response = &DescribeLogStorageConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogStorageConfig
// This API is used to obtain the log storage configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogStorageConfig(request *DescribeLogStorageConfigRequest) (response *DescribeLogStorageConfigResponse, err error) {
    return c.DescribeLogStorageConfigWithContext(context.Background(), request)
}

// DescribeLogStorageConfig
// This API is used to obtain the log storage configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogStorageConfigWithContext(ctx context.Context, request *DescribeLogStorageConfigRequest) (response *DescribeLogStorageConfigResponse, err error) {
    if request == nil {
        request = NewDescribeLogStorageConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogStorageConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogStorageConfig require credential")
    }

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

func NewDescribeLogStorageRecordRequest() (request *DescribeLogStorageRecordRequest) {
    request = &DescribeLogStorageRecordRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogStorageRecord")
    
    
    return
}

func NewDescribeLogStorageRecordResponse() (response *DescribeLogStorageRecordResponse) {
    response = &DescribeLogStorageRecordResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogStorageRecord
// This API is used to obtain the record of stored log size.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogStorageRecord(request *DescribeLogStorageRecordRequest) (response *DescribeLogStorageRecordResponse, err error) {
    return c.DescribeLogStorageRecordWithContext(context.Background(), request)
}

// DescribeLogStorageRecord
// This API is used to obtain the record of stored log size.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLogStorageRecordWithContext(ctx context.Context, request *DescribeLogStorageRecordRequest) (response *DescribeLogStorageRecordResponse, err error) {
    if request == nil {
        request = NewDescribeLogStorageRecordRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogStorageRecord")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogStorageRecord require credential")
    }

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

func NewDescribeLogStorageStatisticRequest() (request *DescribeLogStorageStatisticRequest) {
    request = &DescribeLogStorageStatisticRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogStorageStatistic")
    
    
    return
}

func NewDescribeLogStorageStatisticResponse() (response *DescribeLogStorageStatisticResponse) {
    response = &DescribeLogStorageStatisticResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogStorageStatistic
// This API is used to obtain the statistics of the used log retrieval capacity.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLogStorageStatistic(request *DescribeLogStorageStatisticRequest) (response *DescribeLogStorageStatisticResponse, err error) {
    return c.DescribeLogStorageStatisticWithContext(context.Background(), request)
}

// DescribeLogStorageStatistic
// This API is used to obtain the statistics of the used log retrieval capacity.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLogStorageStatisticWithContext(ctx context.Context, request *DescribeLogStorageStatisticRequest) (response *DescribeLogStorageStatisticResponse, err error) {
    if request == nil {
        request = NewDescribeLogStorageStatisticRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogStorageStatistic")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogStorageStatistic require credential")
    }

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

func NewDescribeLogTypeRequest() (request *DescribeLogTypeRequest) {
    request = &DescribeLogTypeRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLogType")
    
    
    return
}

func NewDescribeLogTypeResponse() (response *DescribeLogTypeResponse) {
    response = &DescribeLogTypeResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLogType
// This API is used to obtain log types, and the returned result of this API indicates temporarily filterable log types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLogType(request *DescribeLogTypeRequest) (response *DescribeLogTypeResponse, err error) {
    return c.DescribeLogTypeWithContext(context.Background(), request)
}

// DescribeLogType
// This API is used to obtain log types, and the returned result of this API indicates temporarily filterable log types.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeLogTypeWithContext(ctx context.Context, request *DescribeLogTypeRequest) (response *DescribeLogTypeResponse, err error) {
    if request == nil {
        request = NewDescribeLogTypeRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLogType")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLogType require credential")
    }

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

func NewDescribeLoginWhiteCombinedListRequest() (request *DescribeLoginWhiteCombinedListRequest) {
    request = &DescribeLoginWhiteCombinedListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLoginWhiteCombinedList")
    
    
    return
}

func NewDescribeLoginWhiteCombinedListResponse() (response *DescribeLoginWhiteCombinedListResponse) {
    response = &DescribeLoginWhiteCombinedListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLoginWhiteCombinedList
// This API is used to obtain the list of cross-region log-in allowlists after merge.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLoginWhiteCombinedList(request *DescribeLoginWhiteCombinedListRequest) (response *DescribeLoginWhiteCombinedListResponse, err error) {
    return c.DescribeLoginWhiteCombinedListWithContext(context.Background(), request)
}

// DescribeLoginWhiteCombinedList
// This API is used to obtain the list of cross-region log-in allowlists after merge.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeLoginWhiteCombinedListWithContext(ctx context.Context, request *DescribeLoginWhiteCombinedListRequest) (response *DescribeLoginWhiteCombinedListResponse, err error) {
    if request == nil {
        request = NewDescribeLoginWhiteCombinedListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLoginWhiteCombinedList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLoginWhiteCombinedList require credential")
    }

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

func NewDescribeLoginWhiteHostListRequest() (request *DescribeLoginWhiteHostListRequest) {
    request = &DescribeLoginWhiteHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLoginWhiteHostList")
    
    
    return
}

func NewDescribeLoginWhiteHostListResponse() (response *DescribeLoginWhiteHostListResponse) {
    response = &DescribeLoginWhiteHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLoginWhiteHostList
// This API is used to query the list of allowlisted machines after merge.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeLoginWhiteHostList(request *DescribeLoginWhiteHostListRequest) (response *DescribeLoginWhiteHostListResponse, err error) {
    return c.DescribeLoginWhiteHostListWithContext(context.Background(), request)
}

// DescribeLoginWhiteHostList
// This API is used to query the list of allowlisted machines after merge.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeLoginWhiteHostListWithContext(ctx context.Context, request *DescribeLoginWhiteHostListRequest) (response *DescribeLoginWhiteHostListResponse, err error) {
    if request == nil {
        request = NewDescribeLoginWhiteHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLoginWhiteHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLoginWhiteHostList require credential")
    }

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

func NewDescribeLoginWhiteListRequest() (request *DescribeLoginWhiteListRequest) {
    request = &DescribeLoginWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeLoginWhiteList")
    
    
    return
}

func NewDescribeLoginWhiteListResponse() (response *DescribeLoginWhiteListResponse) {
    response = &DescribeLoginWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeLoginWhiteList
// This API is used to obtain the cross-region log-in allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeLoginWhiteList(request *DescribeLoginWhiteListRequest) (response *DescribeLoginWhiteListResponse, err error) {
    return c.DescribeLoginWhiteListWithContext(context.Background(), request)
}

// DescribeLoginWhiteList
// This API is used to obtain the cross-region log-in allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) DescribeLoginWhiteListWithContext(ctx context.Context, request *DescribeLoginWhiteListRequest) (response *DescribeLoginWhiteListResponse, err error) {
    if request == nil {
        request = NewDescribeLoginWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeLoginWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeLoginWhiteList require credential")
    }

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

func NewDescribeMachineClearHistoryRequest() (request *DescribeMachineClearHistoryRequest) {
    request = &DescribeMachineClearHistoryRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineClearHistory")
    
    
    return
}

func NewDescribeMachineClearHistoryResponse() (response *DescribeMachineClearHistoryResponse) {
    response = &DescribeMachineClearHistoryResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineClearHistory
// This API is used to query the clearing history records of a machine.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachineClearHistory(request *DescribeMachineClearHistoryRequest) (response *DescribeMachineClearHistoryResponse, err error) {
    return c.DescribeMachineClearHistoryWithContext(context.Background(), request)
}

// DescribeMachineClearHistory
// This API is used to query the clearing history records of a machine.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachineClearHistoryWithContext(ctx context.Context, request *DescribeMachineClearHistoryRequest) (response *DescribeMachineClearHistoryResponse, err error) {
    if request == nil {
        request = NewDescribeMachineClearHistoryRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineClearHistory")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineClearHistory require credential")
    }

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

func NewDescribeMachineDefenseCntRequest() (request *DescribeMachineDefenseCntRequest) {
    request = &DescribeMachineDefenseCntRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineDefenseCnt")
    
    
    return
}

func NewDescribeMachineDefenseCntResponse() (response *DescribeMachineDefenseCntResponse) {
    response = &DescribeMachineDefenseCntResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineDefenseCnt
// This API is used to query the statistics of advanced defense events for hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineDefenseCnt(request *DescribeMachineDefenseCntRequest) (response *DescribeMachineDefenseCntResponse, err error) {
    return c.DescribeMachineDefenseCntWithContext(context.Background(), request)
}

// DescribeMachineDefenseCnt
// This API is used to query the statistics of advanced defense events for hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineDefenseCntWithContext(ctx context.Context, request *DescribeMachineDefenseCntRequest) (response *DescribeMachineDefenseCntResponse, err error) {
    if request == nil {
        request = NewDescribeMachineDefenseCntRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineDefenseCnt")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineDefenseCnt require credential")
    }

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

func NewDescribeMachineFileTamperRulesRequest() (request *DescribeMachineFileTamperRulesRequest) {
    request = &DescribeMachineFileTamperRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineFileTamperRules")
    
    
    return
}

func NewDescribeMachineFileTamperRulesResponse() (response *DescribeMachineFileTamperRulesResponse) {
    response = &DescribeMachineFileTamperRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineFileTamperRules
// This API is used to query the list of host-related core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineFileTamperRules(request *DescribeMachineFileTamperRulesRequest) (response *DescribeMachineFileTamperRulesResponse, err error) {
    return c.DescribeMachineFileTamperRulesWithContext(context.Background(), request)
}

// DescribeMachineFileTamperRules
// This API is used to query the list of host-related core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineFileTamperRulesWithContext(ctx context.Context, request *DescribeMachineFileTamperRulesRequest) (response *DescribeMachineFileTamperRulesResponse, err error) {
    if request == nil {
        request = NewDescribeMachineFileTamperRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineFileTamperRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineFileTamperRules require credential")
    }

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

func NewDescribeMachineGeneralRequest() (request *DescribeMachineGeneralRequest) {
    request = &DescribeMachineGeneralRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineGeneral")
    
    
    return
}

func NewDescribeMachineGeneralResponse() (response *DescribeMachineGeneralResponse) {
    response = &DescribeMachineGeneralResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineGeneral
// This API is used to query the information of the host overview.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMachineGeneral(request *DescribeMachineGeneralRequest) (response *DescribeMachineGeneralResponse, err error) {
    return c.DescribeMachineGeneralWithContext(context.Background(), request)
}

// DescribeMachineGeneral
// This API is used to query the information of the host overview.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMachineGeneralWithContext(ctx context.Context, request *DescribeMachineGeneralRequest) (response *DescribeMachineGeneralResponse, err error) {
    if request == nil {
        request = NewDescribeMachineGeneralRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineGeneral")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineGeneral require credential")
    }

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

func NewDescribeMachineLicenseDetailRequest() (request *DescribeMachineLicenseDetailRequest) {
    request = &DescribeMachineLicenseDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineLicenseDetail")
    
    
    return
}

func NewDescribeMachineLicenseDetailResponse() (response *DescribeMachineLicenseDetailResponse) {
    response = &DescribeMachineLicenseDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineLicenseDetail
// This API is used to query the machine authorization information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineLicenseDetail(request *DescribeMachineLicenseDetailRequest) (response *DescribeMachineLicenseDetailResponse, err error) {
    return c.DescribeMachineLicenseDetailWithContext(context.Background(), request)
}

// DescribeMachineLicenseDetail
// This API is used to query the machine authorization information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineLicenseDetailWithContext(ctx context.Context, request *DescribeMachineLicenseDetailRequest) (response *DescribeMachineLicenseDetailResponse, err error) {
    if request == nil {
        request = NewDescribeMachineLicenseDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineLicenseDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineLicenseDetail require credential")
    }

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

func NewDescribeMachineOsListRequest() (request *DescribeMachineOsListRequest) {
    request = &DescribeMachineOsListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineOsList")
    
    
    return
}

func NewDescribeMachineOsListResponse() (response *DescribeMachineOsListResponse) {
    response = &DescribeMachineOsListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineOsList
// This API is used to query the machine operating system list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMachineOsList(request *DescribeMachineOsListRequest) (response *DescribeMachineOsListResponse, err error) {
    return c.DescribeMachineOsListWithContext(context.Background(), request)
}

// DescribeMachineOsList
// This API is used to query the machine operating system list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMachineOsListWithContext(ctx context.Context, request *DescribeMachineOsListRequest) (response *DescribeMachineOsListResponse, err error) {
    if request == nil {
        request = NewDescribeMachineOsListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineOsList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineOsList require credential")
    }

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

func NewDescribeMachineRegionListRequest() (request *DescribeMachineRegionListRequest) {
    request = &DescribeMachineRegionListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineRegionList")
    
    
    return
}

func NewDescribeMachineRegionListResponse() (response *DescribeMachineRegionListResponse) {
    response = &DescribeMachineRegionListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineRegionList
// This API is used to query the list of host regions.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachineRegionList(request *DescribeMachineRegionListRequest) (response *DescribeMachineRegionListResponse, err error) {
    return c.DescribeMachineRegionListWithContext(context.Background(), request)
}

// DescribeMachineRegionList
// This API is used to query the list of host regions.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachineRegionListWithContext(ctx context.Context, request *DescribeMachineRegionListRequest) (response *DescribeMachineRegionListResponse, err error) {
    if request == nil {
        request = NewDescribeMachineRegionListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineRegionList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineRegionList require credential")
    }

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

func NewDescribeMachineRegionsRequest() (request *DescribeMachineRegionsRequest) {
    request = &DescribeMachineRegionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineRegions")
    
    
    return
}

func NewDescribeMachineRegionsResponse() (response *DescribeMachineRegionsResponse) {
    response = &DescribeMachineRegionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineRegions
// This API is used to obtain the list of machine regions.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineRegions(request *DescribeMachineRegionsRequest) (response *DescribeMachineRegionsResponse, err error) {
    return c.DescribeMachineRegionsWithContext(context.Background(), request)
}

// DescribeMachineRegions
// This API is used to obtain the list of machine regions.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineRegionsWithContext(ctx context.Context, request *DescribeMachineRegionsRequest) (response *DescribeMachineRegionsResponse, err error) {
    if request == nil {
        request = NewDescribeMachineRegionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineRegions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineRegions require credential")
    }

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

func NewDescribeMachineRiskCntRequest() (request *DescribeMachineRiskCntRequest) {
    request = &DescribeMachineRiskCntRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineRiskCnt")
    
    
    return
}

func NewDescribeMachineRiskCntResponse() (response *DescribeMachineRiskCntResponse) {
    response = &DescribeMachineRiskCntResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineRiskCnt
// This API is used to query the statistics of host intrusion detection events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineRiskCnt(request *DescribeMachineRiskCntRequest) (response *DescribeMachineRiskCntResponse, err error) {
    return c.DescribeMachineRiskCntWithContext(context.Background(), request)
}

// DescribeMachineRiskCnt
// This API is used to query the statistics of host intrusion detection events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachineRiskCntWithContext(ctx context.Context, request *DescribeMachineRiskCntRequest) (response *DescribeMachineRiskCntResponse, err error) {
    if request == nil {
        request = NewDescribeMachineRiskCntRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineRiskCnt")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineRiskCnt require credential")
    }

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

func NewDescribeMachineSnapshotRequest() (request *DescribeMachineSnapshotRequest) {
    request = &DescribeMachineSnapshotRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachineSnapshot")
    
    
    return
}

func NewDescribeMachineSnapshotResponse() (response *DescribeMachineSnapshotResponse) {
    response = &DescribeMachineSnapshotResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachineSnapshot
// This API is used to query snapshots created by the host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeMachineSnapshot(request *DescribeMachineSnapshotRequest) (response *DescribeMachineSnapshotResponse, err error) {
    return c.DescribeMachineSnapshotWithContext(context.Background(), request)
}

// DescribeMachineSnapshot
// This API is used to query snapshots created by the host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeMachineSnapshotWithContext(ctx context.Context, request *DescribeMachineSnapshotRequest) (response *DescribeMachineSnapshotResponse, err error) {
    if request == nil {
        request = NewDescribeMachineSnapshotRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachineSnapshot")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachineSnapshot require credential")
    }

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

func NewDescribeMachinesRequest() (request *DescribeMachinesRequest) {
    request = &DescribeMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachines")
    
    
    return
}

func NewDescribeMachinesResponse() (response *DescribeMachinesResponse) {
    response = &DescribeMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachines
// This API is used to obtain the list of hosts in a specific region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachines(request *DescribeMachinesRequest) (response *DescribeMachinesResponse, err error) {
    return c.DescribeMachinesWithContext(context.Background(), request)
}

// DescribeMachines
// This API is used to obtain the list of hosts in a specific region.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMachinesWithContext(ctx context.Context, request *DescribeMachinesRequest) (response *DescribeMachinesResponse, err error) {
    if request == nil {
        request = NewDescribeMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachines require credential")
    }

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

func NewDescribeMachinesSimpleRequest() (request *DescribeMachinesSimpleRequest) {
    request = &DescribeMachinesSimpleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMachinesSimple")
    
    
    return
}

func NewDescribeMachinesSimpleResponse() (response *DescribeMachinesSimpleResponse) {
    response = &DescribeMachinesSimpleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMachinesSimple
// This API is used to obtain the list of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachinesSimple(request *DescribeMachinesSimpleRequest) (response *DescribeMachinesSimpleResponse, err error) {
    return c.DescribeMachinesSimpleWithContext(context.Background(), request)
}

// DescribeMachinesSimple
// This API is used to obtain the list of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMachinesSimpleWithContext(ctx context.Context, request *DescribeMachinesSimpleRequest) (response *DescribeMachinesSimpleResponse, err error) {
    if request == nil {
        request = NewDescribeMachinesSimpleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMachinesSimple")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMachinesSimple require credential")
    }

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

func NewDescribeMalWareListRequest() (request *DescribeMalWareListRequest) {
    request = &DescribeMalWareListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalWareList")
    
    
    return
}

func NewDescribeMalWareListResponse() (response *DescribeMalWareListResponse) {
    response = &DescribeMalWareListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalWareList
// This API is used to obtain the Trojan list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeMalWareList(request *DescribeMalWareListRequest) (response *DescribeMalWareListResponse, err error) {
    return c.DescribeMalWareListWithContext(context.Background(), request)
}

// DescribeMalWareList
// This API is used to obtain the Trojan list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) DescribeMalWareListWithContext(ctx context.Context, request *DescribeMalWareListRequest) (response *DescribeMalWareListResponse, err error) {
    if request == nil {
        request = NewDescribeMalWareListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalWareList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalWareList require credential")
    }

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

func NewDescribeMaliciousRequestWhiteListRequest() (request *DescribeMaliciousRequestWhiteListRequest) {
    request = &DescribeMaliciousRequestWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMaliciousRequestWhiteList")
    
    
    return
}

func NewDescribeMaliciousRequestWhiteListResponse() (response *DescribeMaliciousRequestWhiteListResponse) {
    response = &DescribeMaliciousRequestWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMaliciousRequestWhiteList
// This API is used to query the list of malicious request allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMaliciousRequestWhiteList(request *DescribeMaliciousRequestWhiteListRequest) (response *DescribeMaliciousRequestWhiteListResponse, err error) {
    return c.DescribeMaliciousRequestWhiteListWithContext(context.Background(), request)
}

// DescribeMaliciousRequestWhiteList
// This API is used to query the list of malicious request allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeMaliciousRequestWhiteListWithContext(ctx context.Context, request *DescribeMaliciousRequestWhiteListRequest) (response *DescribeMaliciousRequestWhiteListResponse, err error) {
    if request == nil {
        request = NewDescribeMaliciousRequestWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMaliciousRequestWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMaliciousRequestWhiteList require credential")
    }

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

func NewDescribeMalwareFileRequest() (request *DescribeMalwareFileRequest) {
    request = &DescribeMalwareFileRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareFile")
    
    
    return
}

func NewDescribeMalwareFileResponse() (response *DescribeMalwareFileResponse) {
    response = &DescribeMalwareFileResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareFile
// This API is used to obtain Trojan file download addresses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareFile(request *DescribeMalwareFileRequest) (response *DescribeMalwareFileResponse, err error) {
    return c.DescribeMalwareFileWithContext(context.Background(), request)
}

// DescribeMalwareFile
// This API is used to obtain Trojan file download addresses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareFileWithContext(ctx context.Context, request *DescribeMalwareFileRequest) (response *DescribeMalwareFileResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareFileRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareFile")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareFile require credential")
    }

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

func NewDescribeMalwareInfoRequest() (request *DescribeMalwareInfoRequest) {
    request = &DescribeMalwareInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareInfo")
    
    
    return
}

func NewDescribeMalwareInfoResponse() (response *DescribeMalwareInfoResponse) {
    response = &DescribeMalwareInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareInfo
// This API is used to view malicious file details.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareInfo(request *DescribeMalwareInfoRequest) (response *DescribeMalwareInfoResponse, err error) {
    return c.DescribeMalwareInfoWithContext(context.Background(), request)
}

// DescribeMalwareInfo
// This API is used to view malicious file details.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareInfoWithContext(ctx context.Context, request *DescribeMalwareInfoRequest) (response *DescribeMalwareInfoResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareInfo require credential")
    }

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

func NewDescribeMalwareRiskOverviewRequest() (request *DescribeMalwareRiskOverviewRequest) {
    request = &DescribeMalwareRiskOverviewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareRiskOverview")
    
    
    return
}

func NewDescribeMalwareRiskOverviewResponse() (response *DescribeMalwareRiskOverviewResponse) {
    response = &DescribeMalwareRiskOverviewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareRiskOverview
// This API is used to obtain the information of virus scanning overview.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareRiskOverview(request *DescribeMalwareRiskOverviewRequest) (response *DescribeMalwareRiskOverviewResponse, err error) {
    return c.DescribeMalwareRiskOverviewWithContext(context.Background(), request)
}

// DescribeMalwareRiskOverview
// This API is used to obtain the information of virus scanning overview.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareRiskOverviewWithContext(ctx context.Context, request *DescribeMalwareRiskOverviewRequest) (response *DescribeMalwareRiskOverviewResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareRiskOverviewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareRiskOverview")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareRiskOverview require credential")
    }

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

func NewDescribeMalwareRiskWarningRequest() (request *DescribeMalwareRiskWarningRequest) {
    request = &DescribeMalwareRiskWarningRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareRiskWarning")
    
    
    return
}

func NewDescribeMalwareRiskWarningResponse() (response *DescribeMalwareRiskWarningResponse) {
    response = &DescribeMalwareRiskWarningResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareRiskWarning
// This API is used to open Intrusion Detection - Virus Scanning, and the risk warning content pops up.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareRiskWarning(request *DescribeMalwareRiskWarningRequest) (response *DescribeMalwareRiskWarningResponse, err error) {
    return c.DescribeMalwareRiskWarningWithContext(context.Background(), request)
}

// DescribeMalwareRiskWarning
// This API is used to open Intrusion Detection - Virus Scanning, and the risk warning content pops up.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareRiskWarningWithContext(ctx context.Context, request *DescribeMalwareRiskWarningRequest) (response *DescribeMalwareRiskWarningResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareRiskWarningRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareRiskWarning")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareRiskWarning require credential")
    }

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

func NewDescribeMalwareTimingScanSettingRequest() (request *DescribeMalwareTimingScanSettingRequest) {
    request = &DescribeMalwareTimingScanSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareTimingScanSetting")
    
    
    return
}

func NewDescribeMalwareTimingScanSettingResponse() (response *DescribeMalwareTimingScanSettingResponse) {
    response = &DescribeMalwareTimingScanSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareTimingScanSetting
// This API is used to query the scheduled scan configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareTimingScanSetting(request *DescribeMalwareTimingScanSettingRequest) (response *DescribeMalwareTimingScanSettingResponse, err error) {
    return c.DescribeMalwareTimingScanSettingWithContext(context.Background(), request)
}

// DescribeMalwareTimingScanSetting
// This API is used to query the scheduled scan configuration.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeMalwareTimingScanSettingWithContext(ctx context.Context, request *DescribeMalwareTimingScanSettingRequest) (response *DescribeMalwareTimingScanSettingResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareTimingScanSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareTimingScanSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareTimingScanSetting require credential")
    }

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

func NewDescribeMalwareWhiteListRequest() (request *DescribeMalwareWhiteListRequest) {
    request = &DescribeMalwareWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareWhiteList")
    
    
    return
}

func NewDescribeMalwareWhiteListResponse() (response *DescribeMalwareWhiteListResponse) {
    response = &DescribeMalwareWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareWhiteList
// This API is used to obtain the list of Trojan allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareWhiteList(request *DescribeMalwareWhiteListRequest) (response *DescribeMalwareWhiteListResponse, err error) {
    return c.DescribeMalwareWhiteListWithContext(context.Background(), request)
}

// DescribeMalwareWhiteList
// This API is used to obtain the list of Trojan allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareWhiteListWithContext(ctx context.Context, request *DescribeMalwareWhiteListRequest) (response *DescribeMalwareWhiteListResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareWhiteList require credential")
    }

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

func NewDescribeMalwareWhiteListAffectListRequest() (request *DescribeMalwareWhiteListAffectListRequest) {
    request = &DescribeMalwareWhiteListAffectListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMalwareWhiteListAffectList")
    
    
    return
}

func NewDescribeMalwareWhiteListAffectListResponse() (response *DescribeMalwareWhiteListAffectListResponse) {
    response = &DescribeMalwareWhiteListAffectListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMalwareWhiteListAffectList
// This API is used to obtain the list of affected Trojan allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareWhiteListAffectList(request *DescribeMalwareWhiteListAffectListRequest) (response *DescribeMalwareWhiteListAffectListResponse, err error) {
    return c.DescribeMalwareWhiteListAffectListWithContext(context.Background(), request)
}

// DescribeMalwareWhiteListAffectList
// This API is used to obtain the list of affected Trojan allowlists.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMalwareWhiteListAffectListWithContext(ctx context.Context, request *DescribeMalwareWhiteListAffectListRequest) (response *DescribeMalwareWhiteListAffectListResponse, err error) {
    if request == nil {
        request = NewDescribeMalwareWhiteListAffectListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMalwareWhiteListAffectList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMalwareWhiteListAffectList require credential")
    }

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

func NewDescribeMonthInspectionReportRequest() (request *DescribeMonthInspectionReportRequest) {
    request = &DescribeMonthInspectionReportRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeMonthInspectionReport")
    
    
    return
}

func NewDescribeMonthInspectionReportResponse() (response *DescribeMonthInspectionReportResponse) {
    response = &DescribeMonthInspectionReportResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeMonthInspectionReport
// This API is used to download the monthly inspection report of the security manager.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMonthInspectionReport(request *DescribeMonthInspectionReportRequest) (response *DescribeMonthInspectionReportResponse, err error) {
    return c.DescribeMonthInspectionReportWithContext(context.Background(), request)
}

// DescribeMonthInspectionReport
// This API is used to download the monthly inspection report of the security manager.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeMonthInspectionReportWithContext(ctx context.Context, request *DescribeMonthInspectionReportRequest) (response *DescribeMonthInspectionReportResponse, err error) {
    if request == nil {
        request = NewDescribeMonthInspectionReportRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeMonthInspectionReport")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeMonthInspectionReport require credential")
    }

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

func NewDescribeNetAttackSettingRequest() (request *DescribeNetAttackSettingRequest) {
    request = &DescribeNetAttackSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeNetAttackSetting")
    
    
    return
}

func NewDescribeNetAttackSettingResponse() (response *DescribeNetAttackSettingResponse) {
    response = &DescribeNetAttackSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeNetAttackSetting
// This API is used to query network attack settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeNetAttackSetting(request *DescribeNetAttackSettingRequest) (response *DescribeNetAttackSettingResponse, err error) {
    return c.DescribeNetAttackSettingWithContext(context.Background(), request)
}

// DescribeNetAttackSetting
// This API is used to query network attack settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeNetAttackSettingWithContext(ctx context.Context, request *DescribeNetAttackSettingRequest) (response *DescribeNetAttackSettingResponse, err error) {
    if request == nil {
        request = NewDescribeNetAttackSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeNetAttackSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeNetAttackSetting require credential")
    }

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

func NewDescribeNetAttackWhiteListRequest() (request *DescribeNetAttackWhiteListRequest) {
    request = &DescribeNetAttackWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeNetAttackWhiteList")
    
    
    return
}

func NewDescribeNetAttackWhiteListResponse() (response *DescribeNetAttackWhiteListResponse) {
    response = &DescribeNetAttackWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeNetAttackWhiteList
// This API is used to obtain the network attack allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeNetAttackWhiteList(request *DescribeNetAttackWhiteListRequest) (response *DescribeNetAttackWhiteListResponse, err error) {
    return c.DescribeNetAttackWhiteListWithContext(context.Background(), request)
}

// DescribeNetAttackWhiteList
// This API is used to obtain the network attack allowlist list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeNetAttackWhiteListWithContext(ctx context.Context, request *DescribeNetAttackWhiteListRequest) (response *DescribeNetAttackWhiteListResponse, err error) {
    if request == nil {
        request = NewDescribeNetAttackWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeNetAttackWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeNetAttackWhiteList require credential")
    }

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

func NewDescribeOpenPortStatisticsRequest() (request *DescribeOpenPortStatisticsRequest) {
    request = &DescribeOpenPortStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeOpenPortStatistics")
    
    
    return
}

func NewDescribeOpenPortStatisticsResponse() (response *DescribeOpenPortStatisticsResponse) {
    response = &DescribeOpenPortStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeOpenPortStatistics
// This API is used to obtain the list of port statistics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeOpenPortStatistics(request *DescribeOpenPortStatisticsRequest) (response *DescribeOpenPortStatisticsResponse, err error) {
    return c.DescribeOpenPortStatisticsWithContext(context.Background(), request)
}

// DescribeOpenPortStatistics
// This API is used to obtain the list of port statistics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeOpenPortStatisticsWithContext(ctx context.Context, request *DescribeOpenPortStatisticsRequest) (response *DescribeOpenPortStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeOpenPortStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeOpenPortStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeOpenPortStatistics require credential")
    }

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

func NewDescribeOverviewStatisticsRequest() (request *DescribeOverviewStatisticsRequest) {
    request = &DescribeOverviewStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeOverviewStatistics")
    
    
    return
}

func NewDescribeOverviewStatisticsResponse() (response *DescribeOverviewStatisticsResponse) {
    response = &DescribeOverviewStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeOverviewStatistics
// This API is used to obtain the overview statistics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeOverviewStatistics(request *DescribeOverviewStatisticsRequest) (response *DescribeOverviewStatisticsResponse, err error) {
    return c.DescribeOverviewStatisticsWithContext(context.Background(), request)
}

// DescribeOverviewStatistics
// This API is used to obtain the overview statistics.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeOverviewStatisticsWithContext(ctx context.Context, request *DescribeOverviewStatisticsRequest) (response *DescribeOverviewStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeOverviewStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeOverviewStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeOverviewStatistics require credential")
    }

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

func NewDescribePrivilegeEventInfoRequest() (request *DescribePrivilegeEventInfoRequest) {
    request = &DescribePrivilegeEventInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribePrivilegeEventInfo")
    
    
    return
}

func NewDescribePrivilegeEventInfoResponse() (response *DescribePrivilegeEventInfoResponse) {
    response = &DescribePrivilegeEventInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePrivilegeEventInfo
// This API is used to obtain local privilege escalation information details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribePrivilegeEventInfo(request *DescribePrivilegeEventInfoRequest) (response *DescribePrivilegeEventInfoResponse, err error) {
    return c.DescribePrivilegeEventInfoWithContext(context.Background(), request)
}

// DescribePrivilegeEventInfo
// This API is used to obtain local privilege escalation information details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribePrivilegeEventInfoWithContext(ctx context.Context, request *DescribePrivilegeEventInfoRequest) (response *DescribePrivilegeEventInfoResponse, err error) {
    if request == nil {
        request = NewDescribePrivilegeEventInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribePrivilegeEventInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePrivilegeEventInfo require credential")
    }

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

func NewDescribePrivilegeRulesRequest() (request *DescribePrivilegeRulesRequest) {
    request = &DescribePrivilegeRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribePrivilegeRules")
    
    
    return
}

func NewDescribePrivilegeRulesResponse() (response *DescribePrivilegeRulesResponse) {
    response = &DescribePrivilegeRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePrivilegeRules
// This API is used to obtain the list of local privilege escalation rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribePrivilegeRules(request *DescribePrivilegeRulesRequest) (response *DescribePrivilegeRulesResponse, err error) {
    return c.DescribePrivilegeRulesWithContext(context.Background(), request)
}

// DescribePrivilegeRules
// This API is used to obtain the list of local privilege escalation rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribePrivilegeRulesWithContext(ctx context.Context, request *DescribePrivilegeRulesRequest) (response *DescribePrivilegeRulesResponse, err error) {
    if request == nil {
        request = NewDescribePrivilegeRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribePrivilegeRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePrivilegeRules require credential")
    }

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

func NewDescribeProVersionInfoRequest() (request *DescribeProVersionInfoRequest) {
    request = &DescribeProVersionInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeProVersionInfo")
    
    
    return
}

func NewDescribeProVersionInfoResponse() (response *DescribeProVersionInfoResponse) {
    response = &DescribeProVersionInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeProVersionInfo
// This API is used to obtain the overview information of the Professional edition.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeProVersionInfo(request *DescribeProVersionInfoRequest) (response *DescribeProVersionInfoResponse, err error) {
    return c.DescribeProVersionInfoWithContext(context.Background(), request)
}

// DescribeProVersionInfo
// This API is used to obtain the overview information of the Professional edition.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeProVersionInfoWithContext(ctx context.Context, request *DescribeProVersionInfoRequest) (response *DescribeProVersionInfoResponse, err error) {
    if request == nil {
        request = NewDescribeProVersionInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeProVersionInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeProVersionInfo require credential")
    }

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

func NewDescribeProVersionStatusRequest() (request *DescribeProVersionStatusRequest) {
    request = &DescribeProVersionStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeProVersionStatus")
    
    
    return
}

func NewDescribeProVersionStatusResponse() (response *DescribeProVersionStatusResponse) {
    response = &DescribeProVersionStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeProVersionStatus
// This API is used to check whether a single host or all hosts enable the professional version.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeProVersionStatus(request *DescribeProVersionStatusRequest) (response *DescribeProVersionStatusResponse, err error) {
    return c.DescribeProVersionStatusWithContext(context.Background(), request)
}

// DescribeProVersionStatus
// This API is used to check whether a single host or all hosts enable the professional version.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeProVersionStatusWithContext(ctx context.Context, request *DescribeProVersionStatusRequest) (response *DescribeProVersionStatusResponse, err error) {
    if request == nil {
        request = NewDescribeProVersionStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeProVersionStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeProVersionStatus require credential")
    }

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

func NewDescribeProcessStatisticsRequest() (request *DescribeProcessStatisticsRequest) {
    request = &DescribeProcessStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeProcessStatistics")
    
    
    return
}

func NewDescribeProcessStatisticsResponse() (response *DescribeProcessStatisticsResponse) {
    response = &DescribeProcessStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeProcessStatistics
// This API is used to obtain the process statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeProcessStatistics(request *DescribeProcessStatisticsRequest) (response *DescribeProcessStatisticsResponse, err error) {
    return c.DescribeProcessStatisticsWithContext(context.Background(), request)
}

// DescribeProcessStatistics
// This API is used to obtain the process statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeProcessStatisticsWithContext(ctx context.Context, request *DescribeProcessStatisticsRequest) (response *DescribeProcessStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeProcessStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeProcessStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeProcessStatistics require credential")
    }

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

func NewDescribeProductStatusRequest() (request *DescribeProductStatusRequest) {
    request = &DescribeProductStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeProductStatus")
    
    
    return
}

func NewDescribeProductStatusResponse() (response *DescribeProductStatusResponse) {
    response = &DescribeProductStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeProductStatus
// This API is used to query the product trial status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeProductStatus(request *DescribeProductStatusRequest) (response *DescribeProductStatusResponse, err error) {
    return c.DescribeProductStatusWithContext(context.Background(), request)
}

// DescribeProductStatus
// This API is used to query the product trial status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeProductStatusWithContext(ctx context.Context, request *DescribeProductStatusRequest) (response *DescribeProductStatusResponse, err error) {
    if request == nil {
        request = NewDescribeProductStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeProductStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeProductStatus require credential")
    }

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

func NewDescribePublicProxyInstallCommandRequest() (request *DescribePublicProxyInstallCommandRequest) {
    request = &DescribePublicProxyInstallCommandRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribePublicProxyInstallCommand")
    
    
    return
}

func NewDescribePublicProxyInstallCommandResponse() (response *DescribePublicProxyInstallCommandResponse) {
    response = &DescribePublicProxyInstallCommandResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribePublicProxyInstallCommand
// This API is used to obtain the installation command of the public network access proxy.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribePublicProxyInstallCommand(request *DescribePublicProxyInstallCommandRequest) (response *DescribePublicProxyInstallCommandResponse, err error) {
    return c.DescribePublicProxyInstallCommandWithContext(context.Background(), request)
}

// DescribePublicProxyInstallCommand
// This API is used to obtain the installation command of the public network access proxy.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribePublicProxyInstallCommandWithContext(ctx context.Context, request *DescribePublicProxyInstallCommandRequest) (response *DescribePublicProxyInstallCommandResponse, err error) {
    if request == nil {
        request = NewDescribePublicProxyInstallCommandRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribePublicProxyInstallCommand")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribePublicProxyInstallCommand require credential")
    }

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

func NewDescribeRansomDefenseBackupListRequest() (request *DescribeRansomDefenseBackupListRequest) {
    request = &DescribeRansomDefenseBackupListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseBackupList")
    
    
    return
}

func NewDescribeRansomDefenseBackupListResponse() (response *DescribeRansomDefenseBackupListResponse) {
    response = &DescribeRansomDefenseBackupListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseBackupList
// This API is used to query the list of host snapshot backups.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseBackupList(request *DescribeRansomDefenseBackupListRequest) (response *DescribeRansomDefenseBackupListResponse, err error) {
    return c.DescribeRansomDefenseBackupListWithContext(context.Background(), request)
}

// DescribeRansomDefenseBackupList
// This API is used to query the list of host snapshot backups.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseBackupListWithContext(ctx context.Context, request *DescribeRansomDefenseBackupListRequest) (response *DescribeRansomDefenseBackupListResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseBackupListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseBackupList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseBackupList require credential")
    }

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

func NewDescribeRansomDefenseEventsListRequest() (request *DescribeRansomDefenseEventsListRequest) {
    request = &DescribeRansomDefenseEventsListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseEventsList")
    
    
    return
}

func NewDescribeRansomDefenseEventsListResponse() (response *DescribeRansomDefenseEventsListResponse) {
    response = &DescribeRansomDefenseEventsListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseEventsList
// This API is used to query the anti-ransomware event list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseEventsList(request *DescribeRansomDefenseEventsListRequest) (response *DescribeRansomDefenseEventsListResponse, err error) {
    return c.DescribeRansomDefenseEventsListWithContext(context.Background(), request)
}

// DescribeRansomDefenseEventsList
// This API is used to query the anti-ransomware event list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseEventsListWithContext(ctx context.Context, request *DescribeRansomDefenseEventsListRequest) (response *DescribeRansomDefenseEventsListResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseEventsListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseEventsList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseEventsList require credential")
    }

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

func NewDescribeRansomDefenseMachineListRequest() (request *DescribeRansomDefenseMachineListRequest) {
    request = &DescribeRansomDefenseMachineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseMachineList")
    
    
    return
}

func NewDescribeRansomDefenseMachineListResponse() (response *DescribeRansomDefenseMachineListResponse) {
    response = &DescribeRansomDefenseMachineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseMachineList
// This API is used to query the list of backup details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseMachineList(request *DescribeRansomDefenseMachineListRequest) (response *DescribeRansomDefenseMachineListResponse, err error) {
    return c.DescribeRansomDefenseMachineListWithContext(context.Background(), request)
}

// DescribeRansomDefenseMachineList
// This API is used to query the list of backup details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseMachineListWithContext(ctx context.Context, request *DescribeRansomDefenseMachineListRequest) (response *DescribeRansomDefenseMachineListResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseMachineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseMachineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseMachineList require credential")
    }

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

func NewDescribeRansomDefenseMachineStrategyInfoRequest() (request *DescribeRansomDefenseMachineStrategyInfoRequest) {
    request = &DescribeRansomDefenseMachineStrategyInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseMachineStrategyInfo")
    
    
    return
}

func NewDescribeRansomDefenseMachineStrategyInfoResponse() (response *DescribeRansomDefenseMachineStrategyInfoResponse) {
    response = &DescribeRansomDefenseMachineStrategyInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseMachineStrategyInfo
// This API is used to obtain the list of policies bound to a host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseMachineStrategyInfo(request *DescribeRansomDefenseMachineStrategyInfoRequest) (response *DescribeRansomDefenseMachineStrategyInfoResponse, err error) {
    return c.DescribeRansomDefenseMachineStrategyInfoWithContext(context.Background(), request)
}

// DescribeRansomDefenseMachineStrategyInfo
// This API is used to obtain the list of policies bound to a host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseMachineStrategyInfoWithContext(ctx context.Context, request *DescribeRansomDefenseMachineStrategyInfoRequest) (response *DescribeRansomDefenseMachineStrategyInfoResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseMachineStrategyInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseMachineStrategyInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseMachineStrategyInfo require credential")
    }

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

func NewDescribeRansomDefenseRollBackTaskListRequest() (request *DescribeRansomDefenseRollBackTaskListRequest) {
    request = &DescribeRansomDefenseRollBackTaskListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseRollBackTaskList")
    
    
    return
}

func NewDescribeRansomDefenseRollBackTaskListResponse() (response *DescribeRansomDefenseRollBackTaskListResponse) {
    response = &DescribeRansomDefenseRollBackTaskListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseRollBackTaskList
// This API is used to query the rollback task list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseRollBackTaskList(request *DescribeRansomDefenseRollBackTaskListRequest) (response *DescribeRansomDefenseRollBackTaskListResponse, err error) {
    return c.DescribeRansomDefenseRollBackTaskListWithContext(context.Background(), request)
}

// DescribeRansomDefenseRollBackTaskList
// This API is used to query the rollback task list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseRollBackTaskListWithContext(ctx context.Context, request *DescribeRansomDefenseRollBackTaskListRequest) (response *DescribeRansomDefenseRollBackTaskListResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseRollBackTaskListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseRollBackTaskList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseRollBackTaskList require credential")
    }

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

func NewDescribeRansomDefenseStateRequest() (request *DescribeRansomDefenseStateRequest) {
    request = &DescribeRansomDefenseStateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseState")
    
    
    return
}

func NewDescribeRansomDefenseStateResponse() (response *DescribeRansomDefenseStateResponse) {
    response = &DescribeRansomDefenseStateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseState
// This API is used to obtain user anti-ransomware trends.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseState(request *DescribeRansomDefenseStateRequest) (response *DescribeRansomDefenseStateResponse, err error) {
    return c.DescribeRansomDefenseStateWithContext(context.Background(), request)
}

// DescribeRansomDefenseState
// This API is used to obtain user anti-ransomware trends.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseStateWithContext(ctx context.Context, request *DescribeRansomDefenseStateRequest) (response *DescribeRansomDefenseStateResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseStateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseState")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseState require credential")
    }

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

func NewDescribeRansomDefenseStrategyDetailRequest() (request *DescribeRansomDefenseStrategyDetailRequest) {
    request = &DescribeRansomDefenseStrategyDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseStrategyDetail")
    
    
    return
}

func NewDescribeRansomDefenseStrategyDetailResponse() (response *DescribeRansomDefenseStrategyDetailResponse) {
    response = &DescribeRansomDefenseStrategyDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseStrategyDetail
// This API is used to obtain the policy details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseStrategyDetail(request *DescribeRansomDefenseStrategyDetailRequest) (response *DescribeRansomDefenseStrategyDetailResponse, err error) {
    return c.DescribeRansomDefenseStrategyDetailWithContext(context.Background(), request)
}

// DescribeRansomDefenseStrategyDetail
// This API is used to obtain the policy details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseStrategyDetailWithContext(ctx context.Context, request *DescribeRansomDefenseStrategyDetailRequest) (response *DescribeRansomDefenseStrategyDetailResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseStrategyDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseStrategyDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseStrategyDetail require credential")
    }

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

func NewDescribeRansomDefenseStrategyListRequest() (request *DescribeRansomDefenseStrategyListRequest) {
    request = &DescribeRansomDefenseStrategyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseStrategyList")
    
    
    return
}

func NewDescribeRansomDefenseStrategyListResponse() (response *DescribeRansomDefenseStrategyListResponse) {
    response = &DescribeRansomDefenseStrategyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseStrategyList
// This API is used to query the list of anti-ransomware policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseStrategyList(request *DescribeRansomDefenseStrategyListRequest) (response *DescribeRansomDefenseStrategyListResponse, err error) {
    return c.DescribeRansomDefenseStrategyListWithContext(context.Background(), request)
}

// DescribeRansomDefenseStrategyList
// This API is used to query the list of anti-ransomware policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseStrategyListWithContext(ctx context.Context, request *DescribeRansomDefenseStrategyListRequest) (response *DescribeRansomDefenseStrategyListResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseStrategyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseStrategyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseStrategyList require credential")
    }

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

func NewDescribeRansomDefenseStrategyMachinesRequest() (request *DescribeRansomDefenseStrategyMachinesRequest) {
    request = &DescribeRansomDefenseStrategyMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseStrategyMachines")
    
    
    return
}

func NewDescribeRansomDefenseStrategyMachinesResponse() (response *DescribeRansomDefenseStrategyMachinesResponse) {
    response = &DescribeRansomDefenseStrategyMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseStrategyMachines
// This API is used to query the list of machines bound to an anti-ransomware policy.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseStrategyMachines(request *DescribeRansomDefenseStrategyMachinesRequest) (response *DescribeRansomDefenseStrategyMachinesResponse, err error) {
    return c.DescribeRansomDefenseStrategyMachinesWithContext(context.Background(), request)
}

// DescribeRansomDefenseStrategyMachines
// This API is used to query the list of machines bound to an anti-ransomware policy.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRansomDefenseStrategyMachinesWithContext(ctx context.Context, request *DescribeRansomDefenseStrategyMachinesRequest) (response *DescribeRansomDefenseStrategyMachinesResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseStrategyMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseStrategyMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseStrategyMachines require credential")
    }

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

func NewDescribeRansomDefenseTrendRequest() (request *DescribeRansomDefenseTrendRequest) {
    request = &DescribeRansomDefenseTrendRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRansomDefenseTrend")
    
    
    return
}

func NewDescribeRansomDefenseTrendResponse() (response *DescribeRansomDefenseTrendResponse) {
    response = &DescribeRansomDefenseTrendResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRansomDefenseTrend
// This API is used to obtain the ransomware situation across the entire network.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseTrend(request *DescribeRansomDefenseTrendRequest) (response *DescribeRansomDefenseTrendResponse, err error) {
    return c.DescribeRansomDefenseTrendWithContext(context.Background(), request)
}

// DescribeRansomDefenseTrend
// This API is used to obtain the ransomware situation across the entire network.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRansomDefenseTrendWithContext(ctx context.Context, request *DescribeRansomDefenseTrendRequest) (response *DescribeRansomDefenseTrendResponse, err error) {
    if request == nil {
        request = NewDescribeRansomDefenseTrendRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRansomDefenseTrend")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRansomDefenseTrend require credential")
    }

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

func NewDescribeRecommendedProtectCpuRequest() (request *DescribeRecommendedProtectCpuRequest) {
    request = &DescribeRecommendedProtectCpuRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRecommendedProtectCpu")
    
    
    return
}

func NewDescribeRecommendedProtectCpuResponse() (response *DescribeRecommendedProtectCpuResponse) {
    response = &DescribeRecommendedProtectCpuResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRecommendedProtectCpu
// This API is used to query the recommended number of protection cores for purchase.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRecommendedProtectCpu(request *DescribeRecommendedProtectCpuRequest) (response *DescribeRecommendedProtectCpuResponse, err error) {
    return c.DescribeRecommendedProtectCpuWithContext(context.Background(), request)
}

// DescribeRecommendedProtectCpu
// This API is used to query the recommended number of protection cores for purchase.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRecommendedProtectCpuWithContext(ctx context.Context, request *DescribeRecommendedProtectCpuRequest) (response *DescribeRecommendedProtectCpuResponse, err error) {
    if request == nil {
        request = NewDescribeRecommendedProtectCpuRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRecommendedProtectCpu")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRecommendedProtectCpu require credential")
    }

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

func NewDescribeReverseShellEventInfoRequest() (request *DescribeReverseShellEventInfoRequest) {
    request = &DescribeReverseShellEventInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeReverseShellEventInfo")
    
    
    return
}

func NewDescribeReverseShellEventInfoResponse() (response *DescribeReverseShellEventInfoResponse) {
    response = &DescribeReverseShellEventInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeReverseShellEventInfo
// This API is used to query reverse shell details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeReverseShellEventInfo(request *DescribeReverseShellEventInfoRequest) (response *DescribeReverseShellEventInfoResponse, err error) {
    return c.DescribeReverseShellEventInfoWithContext(context.Background(), request)
}

// DescribeReverseShellEventInfo
// This API is used to query reverse shell details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
func (c *Client) DescribeReverseShellEventInfoWithContext(ctx context.Context, request *DescribeReverseShellEventInfoRequest) (response *DescribeReverseShellEventInfoResponse, err error) {
    if request == nil {
        request = NewDescribeReverseShellEventInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeReverseShellEventInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeReverseShellEventInfo require credential")
    }

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

func NewDescribeReverseShellEventsRequest() (request *DescribeReverseShellEventsRequest) {
    request = &DescribeReverseShellEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeReverseShellEvents")
    
    
    return
}

func NewDescribeReverseShellEventsResponse() (response *DescribeReverseShellEventsResponse) {
    response = &DescribeReverseShellEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeReverseShellEvents
// This API is used to obtain the list of Reverse Shell.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeReverseShellEvents(request *DescribeReverseShellEventsRequest) (response *DescribeReverseShellEventsResponse, err error) {
    return c.DescribeReverseShellEventsWithContext(context.Background(), request)
}

// DescribeReverseShellEvents
// This API is used to obtain the list of Reverse Shell.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeReverseShellEventsWithContext(ctx context.Context, request *DescribeReverseShellEventsRequest) (response *DescribeReverseShellEventsResponse, err error) {
    if request == nil {
        request = NewDescribeReverseShellEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeReverseShellEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeReverseShellEvents require credential")
    }

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

func NewDescribeReverseShellRulesRequest() (request *DescribeReverseShellRulesRequest) {
    request = &DescribeReverseShellRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeReverseShellRules")
    
    
    return
}

func NewDescribeReverseShellRulesResponse() (response *DescribeReverseShellRulesResponse) {
    response = &DescribeReverseShellRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeReverseShellRules
// This API is used to obtain the list of Reverse Shell rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeReverseShellRules(request *DescribeReverseShellRulesRequest) (response *DescribeReverseShellRulesResponse, err error) {
    return c.DescribeReverseShellRulesWithContext(context.Background(), request)
}

// DescribeReverseShellRules
// This API is used to obtain the list of Reverse Shell rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeReverseShellRulesWithContext(ctx context.Context, request *DescribeReverseShellRulesRequest) (response *DescribeReverseShellRulesResponse, err error) {
    if request == nil {
        request = NewDescribeReverseShellRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeReverseShellRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeReverseShellRules require credential")
    }

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

func NewDescribeRiskBatchStatusRequest() (request *DescribeRiskBatchStatusRequest) {
    request = &DescribeRiskBatchStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskBatchStatus")
    
    
    return
}

func NewDescribeRiskBatchStatusResponse() (response *DescribeRiskBatchStatusResponse) {
    response = &DescribeRiskBatchStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskBatchStatus
// This API is used to query if the intrusion detection event update task is completed.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskBatchStatus(request *DescribeRiskBatchStatusRequest) (response *DescribeRiskBatchStatusResponse, err error) {
    return c.DescribeRiskBatchStatusWithContext(context.Background(), request)
}

// DescribeRiskBatchStatus
// This API is used to query if the intrusion detection event update task is completed.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskBatchStatusWithContext(ctx context.Context, request *DescribeRiskBatchStatusRequest) (response *DescribeRiskBatchStatusResponse, err error) {
    if request == nil {
        request = NewDescribeRiskBatchStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskBatchStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskBatchStatus require credential")
    }

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

func NewDescribeRiskDnsEventInfoRequest() (request *DescribeRiskDnsEventInfoRequest) {
    request = &DescribeRiskDnsEventInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskDnsEventInfo")
    
    
    return
}

func NewDescribeRiskDnsEventInfoResponse() (response *DescribeRiskDnsEventInfoResponse) {
    response = &DescribeRiskDnsEventInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskDnsEventInfo
// This API is used to query malicious request event details.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskDnsEventInfo(request *DescribeRiskDnsEventInfoRequest) (response *DescribeRiskDnsEventInfoResponse, err error) {
    return c.DescribeRiskDnsEventInfoWithContext(context.Background(), request)
}

// DescribeRiskDnsEventInfo
// This API is used to query malicious request event details.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskDnsEventInfoWithContext(ctx context.Context, request *DescribeRiskDnsEventInfoRequest) (response *DescribeRiskDnsEventInfoResponse, err error) {
    if request == nil {
        request = NewDescribeRiskDnsEventInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskDnsEventInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskDnsEventInfo require credential")
    }

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

func NewDescribeRiskDnsEventListRequest() (request *DescribeRiskDnsEventListRequest) {
    request = &DescribeRiskDnsEventListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskDnsEventList")
    
    
    return
}

func NewDescribeRiskDnsEventListResponse() (response *DescribeRiskDnsEventListResponse) {
    response = &DescribeRiskDnsEventListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskDnsEventList
// This API is used to obtain the list of malicious request events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskDnsEventList(request *DescribeRiskDnsEventListRequest) (response *DescribeRiskDnsEventListResponse, err error) {
    return c.DescribeRiskDnsEventListWithContext(context.Background(), request)
}

// DescribeRiskDnsEventList
// This API is used to obtain the list of malicious request events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskDnsEventListWithContext(ctx context.Context, request *DescribeRiskDnsEventListRequest) (response *DescribeRiskDnsEventListResponse, err error) {
    if request == nil {
        request = NewDescribeRiskDnsEventListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskDnsEventList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskDnsEventList require credential")
    }

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

func NewDescribeRiskDnsInfoRequest() (request *DescribeRiskDnsInfoRequest) {
    request = &DescribeRiskDnsInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskDnsInfo")
    
    
    return
}

func NewDescribeRiskDnsInfoResponse() (response *DescribeRiskDnsInfoResponse) {
    response = &DescribeRiskDnsInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskDnsInfo
// This API is used to query malicious request details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskDnsInfo(request *DescribeRiskDnsInfoRequest) (response *DescribeRiskDnsInfoResponse, err error) {
    return c.DescribeRiskDnsInfoWithContext(context.Background(), request)
}

// DescribeRiskDnsInfo
// This API is used to query malicious request details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeRiskDnsInfoWithContext(ctx context.Context, request *DescribeRiskDnsInfoRequest) (response *DescribeRiskDnsInfoResponse, err error) {
    if request == nil {
        request = NewDescribeRiskDnsInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskDnsInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskDnsInfo require credential")
    }

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

func NewDescribeRiskDnsListRequest() (request *DescribeRiskDnsListRequest) {
    request = &DescribeRiskDnsListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskDnsList")
    
    
    return
}

func NewDescribeRiskDnsListResponse() (response *DescribeRiskDnsListResponse) {
    response = &DescribeRiskDnsListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskDnsList
// This API is used to obtain the malicious request list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRiskDnsList(request *DescribeRiskDnsListRequest) (response *DescribeRiskDnsListResponse, err error) {
    return c.DescribeRiskDnsListWithContext(context.Background(), request)
}

// DescribeRiskDnsList
// This API is used to obtain the malicious request list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeRiskDnsListWithContext(ctx context.Context, request *DescribeRiskDnsListRequest) (response *DescribeRiskDnsListResponse, err error) {
    if request == nil {
        request = NewDescribeRiskDnsListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskDnsList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskDnsList require credential")
    }

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

func NewDescribeRiskDnsPolicyListRequest() (request *DescribeRiskDnsPolicyListRequest) {
    request = &DescribeRiskDnsPolicyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskDnsPolicyList")
    
    
    return
}

func NewDescribeRiskDnsPolicyListResponse() (response *DescribeRiskDnsPolicyListResponse) {
    response = &DescribeRiskDnsPolicyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskDnsPolicyList
// This API is used to obtain the list of malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskDnsPolicyList(request *DescribeRiskDnsPolicyListRequest) (response *DescribeRiskDnsPolicyListResponse, err error) {
    return c.DescribeRiskDnsPolicyListWithContext(context.Background(), request)
}

// DescribeRiskDnsPolicyList
// This API is used to obtain the list of malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskDnsPolicyListWithContext(ctx context.Context, request *DescribeRiskDnsPolicyListRequest) (response *DescribeRiskDnsPolicyListResponse, err error) {
    if request == nil {
        request = NewDescribeRiskDnsPolicyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskDnsPolicyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskDnsPolicyList require credential")
    }

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

func NewDescribeRiskProcessEventsRequest() (request *DescribeRiskProcessEventsRequest) {
    request = &DescribeRiskProcessEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeRiskProcessEvents")
    
    
    return
}

func NewDescribeRiskProcessEventsResponse() (response *DescribeRiskProcessEventsResponse) {
    response = &DescribeRiskProcessEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeRiskProcessEvents
// This API is used to obtain the list of abnormal processes.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskProcessEvents(request *DescribeRiskProcessEventsRequest) (response *DescribeRiskProcessEventsResponse, err error) {
    return c.DescribeRiskProcessEventsWithContext(context.Background(), request)
}

// DescribeRiskProcessEvents
// This API is used to obtain the list of abnormal processes.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeRiskProcessEventsWithContext(ctx context.Context, request *DescribeRiskProcessEventsRequest) (response *DescribeRiskProcessEventsResponse, err error) {
    if request == nil {
        request = NewDescribeRiskProcessEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeRiskProcessEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeRiskProcessEvents require credential")
    }

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

func NewDescribeSafeInfoRequest() (request *DescribeSafeInfoRequest) {
    request = &DescribeSafeInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSafeInfo")
    
    
    return
}

func NewDescribeSafeInfoResponse() (response *DescribeSafeInfoResponse) {
    response = &DescribeSafeInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSafeInfo
// This API is used to query the .security notification information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) DescribeSafeInfo(request *DescribeSafeInfoRequest) (response *DescribeSafeInfoResponse, err error) {
    return c.DescribeSafeInfoWithContext(context.Background(), request)
}

// DescribeSafeInfo
// This API is used to query the .security notification information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) DescribeSafeInfoWithContext(ctx context.Context, request *DescribeSafeInfoRequest) (response *DescribeSafeInfoResponse, err error) {
    if request == nil {
        request = NewDescribeSafeInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSafeInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSafeInfo require credential")
    }

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

func NewDescribeScanMalwareScheduleRequest() (request *DescribeScanMalwareScheduleRequest) {
    request = &DescribeScanMalwareScheduleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanMalwareSchedule")
    
    
    return
}

func NewDescribeScanMalwareScheduleResponse() (response *DescribeScanMalwareScheduleResponse) {
    response = &DescribeScanMalwareScheduleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanMalwareSchedule
// This API is used to query the Trojan scan progress.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanMalwareSchedule(request *DescribeScanMalwareScheduleRequest) (response *DescribeScanMalwareScheduleResponse, err error) {
    return c.DescribeScanMalwareScheduleWithContext(context.Background(), request)
}

// DescribeScanMalwareSchedule
// This API is used to query the Trojan scan progress.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanMalwareScheduleWithContext(ctx context.Context, request *DescribeScanMalwareScheduleRequest) (response *DescribeScanMalwareScheduleResponse, err error) {
    if request == nil {
        request = NewDescribeScanMalwareScheduleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanMalwareSchedule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanMalwareSchedule require credential")
    }

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

func NewDescribeScanScheduleRequest() (request *DescribeScanScheduleRequest) {
    request = &DescribeScanScheduleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanSchedule")
    
    
    return
}

func NewDescribeScanScheduleResponse() (response *DescribeScanScheduleResponse) {
    response = &DescribeScanScheduleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanSchedule
// This API is used to query the detection progress by taskid.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanSchedule(request *DescribeScanScheduleRequest) (response *DescribeScanScheduleResponse, err error) {
    return c.DescribeScanScheduleWithContext(context.Background(), request)
}

// DescribeScanSchedule
// This API is used to query the detection progress by taskid.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanScheduleWithContext(ctx context.Context, request *DescribeScanScheduleRequest) (response *DescribeScanScheduleResponse, err error) {
    if request == nil {
        request = NewDescribeScanScheduleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanSchedule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanSchedule require credential")
    }

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

func NewDescribeScanStateRequest() (request *DescribeScanStateRequest) {
    request = &DescribeScanStateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanState")
    
    
    return
}

func NewDescribeScanStateResponse() (response *DescribeScanStateResponse) {
    response = &DescribeScanStateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanState
// This API is used to query the status of recent scan tasks of the corresponding module.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanState(request *DescribeScanStateRequest) (response *DescribeScanStateResponse, err error) {
    return c.DescribeScanStateWithContext(context.Background(), request)
}

// DescribeScanState
// This API is used to query the status of recent scan tasks of the corresponding module.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanStateWithContext(ctx context.Context, request *DescribeScanStateRequest) (response *DescribeScanStateResponse, err error) {
    if request == nil {
        request = NewDescribeScanStateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanState")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanState require credential")
    }

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

func NewDescribeScanTaskDetailsRequest() (request *DescribeScanTaskDetailsRequest) {
    request = &DescribeScanTaskDetailsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanTaskDetails")
    
    
    return
}

func NewDescribeScanTaskDetailsResponse() (response *DescribeScanTaskDetailsResponse) {
    response = &DescribeScanTaskDetailsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanTaskDetails
// This API is used to query the scan task details and scan progress information/exceptions.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeScanTaskDetails(request *DescribeScanTaskDetailsRequest) (response *DescribeScanTaskDetailsResponse, err error) {
    return c.DescribeScanTaskDetailsWithContext(context.Background(), request)
}

// DescribeScanTaskDetails
// This API is used to query the scan task details and scan progress information/exceptions.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeScanTaskDetailsWithContext(ctx context.Context, request *DescribeScanTaskDetailsRequest) (response *DescribeScanTaskDetailsResponse, err error) {
    if request == nil {
        request = NewDescribeScanTaskDetailsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanTaskDetails")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanTaskDetails require credential")
    }

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

func NewDescribeScanTaskStatusRequest() (request *DescribeScanTaskStatusRequest) {
    request = &DescribeScanTaskStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanTaskStatus")
    
    
    return
}

func NewDescribeScanTaskStatusResponse() (response *DescribeScanTaskStatusResponse) {
    response = &DescribeScanTaskStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanTaskStatus
// This API is used to query the list of machine scan statuses for filtering.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanTaskStatus(request *DescribeScanTaskStatusRequest) (response *DescribeScanTaskStatusResponse, err error) {
    return c.DescribeScanTaskStatusWithContext(context.Background(), request)
}

// DescribeScanTaskStatus
// This API is used to query the list of machine scan statuses for filtering.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScanTaskStatusWithContext(ctx context.Context, request *DescribeScanTaskStatusRequest) (response *DescribeScanTaskStatusResponse, err error) {
    if request == nil {
        request = NewDescribeScanTaskStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanTaskStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanTaskStatus require credential")
    }

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

func NewDescribeScanVulSettingRequest() (request *DescribeScanVulSettingRequest) {
    request = &DescribeScanVulSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScanVulSetting")
    
    
    return
}

func NewDescribeScanVulSettingResponse() (response *DescribeScanVulSettingResponse) {
    response = &DescribeScanVulSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScanVulSetting
// This API is used to query the configuration for regular detection.
//
// error code that may be returned:
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeScanVulSetting(request *DescribeScanVulSettingRequest) (response *DescribeScanVulSettingResponse, err error) {
    return c.DescribeScanVulSettingWithContext(context.Background(), request)
}

// DescribeScanVulSetting
// This API is used to query the configuration for regular detection.
//
// error code that may be returned:
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeScanVulSettingWithContext(ctx context.Context, request *DescribeScanVulSettingRequest) (response *DescribeScanVulSettingResponse, err error) {
    if request == nil {
        request = NewDescribeScanVulSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScanVulSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScanVulSetting require credential")
    }

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

func NewDescribeScreenAttackHotspotRequest() (request *DescribeScreenAttackHotspotRequest) {
    request = &DescribeScreenAttackHotspotRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenAttackHotspot")
    
    
    return
}

func NewDescribeScreenAttackHotspotResponse() (response *DescribeScreenAttackHotspotResponse) {
    response = &DescribeScreenAttackHotspotResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenAttackHotspot
// This API is used to visually obtain the attacked hot spots across the entire network on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenAttackHotspot(request *DescribeScreenAttackHotspotRequest) (response *DescribeScreenAttackHotspotResponse, err error) {
    return c.DescribeScreenAttackHotspotWithContext(context.Background(), request)
}

// DescribeScreenAttackHotspot
// This API is used to visually obtain the attacked hot spots across the entire network on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenAttackHotspotWithContext(ctx context.Context, request *DescribeScreenAttackHotspotRequest) (response *DescribeScreenAttackHotspotResponse, err error) {
    if request == nil {
        request = NewDescribeScreenAttackHotspotRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenAttackHotspot")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenAttackHotspot require credential")
    }

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

func NewDescribeScreenBroadcastsRequest() (request *DescribeScreenBroadcastsRequest) {
    request = &DescribeScreenBroadcastsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenBroadcasts")
    
    
    return
}

func NewDescribeScreenBroadcastsResponse() (response *DescribeScreenBroadcastsResponse) {
    response = &DescribeScreenBroadcastsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenBroadcasts
// This API is used to obtain the security report on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenBroadcasts(request *DescribeScreenBroadcastsRequest) (response *DescribeScreenBroadcastsResponse, err error) {
    return c.DescribeScreenBroadcastsWithContext(context.Background(), request)
}

// DescribeScreenBroadcasts
// This API is used to obtain the security report on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenBroadcastsWithContext(ctx context.Context, request *DescribeScreenBroadcastsRequest) (response *DescribeScreenBroadcastsResponse, err error) {
    if request == nil {
        request = NewDescribeScreenBroadcastsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenBroadcasts")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenBroadcasts require credential")
    }

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

func NewDescribeScreenDefenseTrendsRequest() (request *DescribeScreenDefenseTrendsRequest) {
    request = &DescribeScreenDefenseTrendsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenDefenseTrends")
    
    
    return
}

func NewDescribeScreenDefenseTrendsResponse() (response *DescribeScreenDefenseTrendsResponse) {
    response = &DescribeScreenDefenseTrendsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenDefenseTrends
// This API is used to obtain the visualized attack and defense trends on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenDefenseTrends(request *DescribeScreenDefenseTrendsRequest) (response *DescribeScreenDefenseTrendsResponse, err error) {
    return c.DescribeScreenDefenseTrendsWithContext(context.Background(), request)
}

// DescribeScreenDefenseTrends
// This API is used to obtain the visualized attack and defense trends on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenDefenseTrendsWithContext(ctx context.Context, request *DescribeScreenDefenseTrendsRequest) (response *DescribeScreenDefenseTrendsResponse, err error) {
    if request == nil {
        request = NewDescribeScreenDefenseTrendsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenDefenseTrends")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenDefenseTrends require credential")
    }

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

func NewDescribeScreenEmergentMsgRequest() (request *DescribeScreenEmergentMsgRequest) {
    request = &DescribeScreenEmergentMsgRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenEmergentMsg")
    
    
    return
}

func NewDescribeScreenEmergentMsgResponse() (response *DescribeScreenEmergentMsgResponse) {
    response = &DescribeScreenEmergentMsgResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenEmergentMsg
// This API is used to obtain the visualized emergency notification on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenEmergentMsg(request *DescribeScreenEmergentMsgRequest) (response *DescribeScreenEmergentMsgResponse, err error) {
    return c.DescribeScreenEmergentMsgWithContext(context.Background(), request)
}

// DescribeScreenEmergentMsg
// This API is used to obtain the visualized emergency notification on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenEmergentMsgWithContext(ctx context.Context, request *DescribeScreenEmergentMsgRequest) (response *DescribeScreenEmergentMsgResponse, err error) {
    if request == nil {
        request = NewDescribeScreenEmergentMsgRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenEmergentMsg")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenEmergentMsg require credential")
    }

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

func NewDescribeScreenEventsCntRequest() (request *DescribeScreenEventsCntRequest) {
    request = &DescribeScreenEventsCntRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenEventsCnt")
    
    
    return
}

func NewDescribeScreenEventsCntResponse() (response *DescribeScreenEventsCntResponse) {
    response = &DescribeScreenEventsCntResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenEventsCnt
// This API is used to obtain the statistics data of events on the security overview page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenEventsCnt(request *DescribeScreenEventsCntRequest) (response *DescribeScreenEventsCntResponse, err error) {
    return c.DescribeScreenEventsCntWithContext(context.Background(), request)
}

// DescribeScreenEventsCnt
// This API is used to obtain the statistics data of events on the security overview page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenEventsCntWithContext(ctx context.Context, request *DescribeScreenEventsCntRequest) (response *DescribeScreenEventsCntResponse, err error) {
    if request == nil {
        request = NewDescribeScreenEventsCntRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenEventsCnt")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenEventsCnt require credential")
    }

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

func NewDescribeScreenGeneralStatRequest() (request *DescribeScreenGeneralStatRequest) {
    request = &DescribeScreenGeneralStatRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenGeneralStat")
    
    
    return
}

func NewDescribeScreenGeneralStatResponse() (response *DescribeScreenGeneralStatResponse) {
    response = &DescribeScreenGeneralStatResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenGeneralStat
// This API is used to obtain the visualized statistics data of hosts on the screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenGeneralStat(request *DescribeScreenGeneralStatRequest) (response *DescribeScreenGeneralStatResponse, err error) {
    return c.DescribeScreenGeneralStatWithContext(context.Background(), request)
}

// DescribeScreenGeneralStat
// This API is used to obtain the visualized statistics data of hosts on the screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenGeneralStatWithContext(ctx context.Context, request *DescribeScreenGeneralStatRequest) (response *DescribeScreenGeneralStatResponse, err error) {
    if request == nil {
        request = NewDescribeScreenGeneralStatRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenGeneralStat")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenGeneralStat require credential")
    }

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

func NewDescribeScreenHostInvasionRequest() (request *DescribeScreenHostInvasionRequest) {
    request = &DescribeScreenHostInvasionRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenHostInvasion")
    
    
    return
}

func NewDescribeScreenHostInvasionResponse() (response *DescribeScreenHostInvasionResponse) {
    response = &DescribeScreenHostInvasionResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenHostInvasion
// This API is used to obtain the visualized host intrusion details on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenHostInvasion(request *DescribeScreenHostInvasionRequest) (response *DescribeScreenHostInvasionResponse, err error) {
    return c.DescribeScreenHostInvasionWithContext(context.Background(), request)
}

// DescribeScreenHostInvasion
// This API is used to obtain the visualized host intrusion details on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenHostInvasionWithContext(ctx context.Context, request *DescribeScreenHostInvasionRequest) (response *DescribeScreenHostInvasionResponse, err error) {
    if request == nil {
        request = NewDescribeScreenHostInvasionRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenHostInvasion")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenHostInvasion require credential")
    }

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

func NewDescribeScreenMachineRegionsRequest() (request *DescribeScreenMachineRegionsRequest) {
    request = &DescribeScreenMachineRegionsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenMachineRegions")
    
    
    return
}

func NewDescribeScreenMachineRegionsResponse() (response *DescribeScreenMachineRegionsResponse) {
    response = &DescribeScreenMachineRegionsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenMachineRegions
// This API is used to obtain the list of available visualized host regions on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenMachineRegions(request *DescribeScreenMachineRegionsRequest) (response *DescribeScreenMachineRegionsResponse, err error) {
    return c.DescribeScreenMachineRegionsWithContext(context.Background(), request)
}

// DescribeScreenMachineRegions
// This API is used to obtain the list of available visualized host regions on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenMachineRegionsWithContext(ctx context.Context, request *DescribeScreenMachineRegionsRequest) (response *DescribeScreenMachineRegionsResponse, err error) {
    if request == nil {
        request = NewDescribeScreenMachineRegionsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenMachineRegions")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenMachineRegions require credential")
    }

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

func NewDescribeScreenMachinesRequest() (request *DescribeScreenMachinesRequest) {
    request = &DescribeScreenMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenMachines")
    
    
    return
}

func NewDescribeScreenMachinesResponse() (response *DescribeScreenMachinesResponse) {
    response = &DescribeScreenMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenMachines
// This API is used to obtain the visualized list of host regions on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenMachines(request *DescribeScreenMachinesRequest) (response *DescribeScreenMachinesResponse, err error) {
    return c.DescribeScreenMachinesWithContext(context.Background(), request)
}

// DescribeScreenMachines
// This API is used to obtain the visualized list of host regions on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenMachinesWithContext(ctx context.Context, request *DescribeScreenMachinesRequest) (response *DescribeScreenMachinesResponse, err error) {
    if request == nil {
        request = NewDescribeScreenMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenMachines require credential")
    }

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

func NewDescribeScreenProtectionCntRequest() (request *DescribeScreenProtectionCntRequest) {
    request = &DescribeScreenProtectionCntRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenProtectionCnt")
    
    
    return
}

func NewDescribeScreenProtectionCntResponse() (response *DescribeScreenProtectionCntResponse) {
    response = &DescribeScreenProtectionCntResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenProtectionCnt
// This API is used to obtain the visualized introduction of CWPP engine on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenProtectionCnt(request *DescribeScreenProtectionCntRequest) (response *DescribeScreenProtectionCntResponse, err error) {
    return c.DescribeScreenProtectionCntWithContext(context.Background(), request)
}

// DescribeScreenProtectionCnt
// This API is used to obtain the visualized introduction of CWPP engine on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenProtectionCntWithContext(ctx context.Context, request *DescribeScreenProtectionCntRequest) (response *DescribeScreenProtectionCntResponse, err error) {
    if request == nil {
        request = NewDescribeScreenProtectionCntRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenProtectionCnt")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenProtectionCnt require credential")
    }

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

func NewDescribeScreenProtectionStatRequest() (request *DescribeScreenProtectionStatRequest) {
    request = &DescribeScreenProtectionStatRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenProtectionStat")
    
    
    return
}

func NewDescribeScreenProtectionStatResponse() (response *DescribeScreenProtectionStatResponse) {
    response = &DescribeScreenProtectionStatResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenProtectionStat
// This API is used to obtain the security protection status on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenProtectionStat(request *DescribeScreenProtectionStatRequest) (response *DescribeScreenProtectionStatResponse, err error) {
    return c.DescribeScreenProtectionStatWithContext(context.Background(), request)
}

// DescribeScreenProtectionStat
// This API is used to obtain the security protection status on the large screen.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeScreenProtectionStatWithContext(ctx context.Context, request *DescribeScreenProtectionStatRequest) (response *DescribeScreenProtectionStatResponse, err error) {
    if request == nil {
        request = NewDescribeScreenProtectionStatRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenProtectionStat")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenProtectionStat require credential")
    }

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

func NewDescribeScreenRiskAssetsTopRequest() (request *DescribeScreenRiskAssetsTopRequest) {
    request = &DescribeScreenRiskAssetsTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeScreenRiskAssetsTop")
    
    
    return
}

func NewDescribeScreenRiskAssetsTopResponse() (response *DescribeScreenRiskAssetsTopResponse) {
    response = &DescribeScreenRiskAssetsTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeScreenRiskAssetsTop
// This API is used to count today's risky assets.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenRiskAssetsTop(request *DescribeScreenRiskAssetsTopRequest) (response *DescribeScreenRiskAssetsTopResponse, err error) {
    return c.DescribeScreenRiskAssetsTopWithContext(context.Background(), request)
}

// DescribeScreenRiskAssetsTop
// This API is used to count today's risky assets.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeScreenRiskAssetsTopWithContext(ctx context.Context, request *DescribeScreenRiskAssetsTopRequest) (response *DescribeScreenRiskAssetsTopResponse, err error) {
    if request == nil {
        request = NewDescribeScreenRiskAssetsTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeScreenRiskAssetsTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeScreenRiskAssetsTop require credential")
    }

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

func NewDescribeSearchLogsRequest() (request *DescribeSearchLogsRequest) {
    request = &DescribeSearchLogsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSearchLogs")
    
    
    return
}

func NewDescribeSearchLogsResponse() (response *DescribeSearchLogsResponse) {
    response = &DescribeSearchLogsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSearchLogs
// This API is used to obtain historical search records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeSearchLogs(request *DescribeSearchLogsRequest) (response *DescribeSearchLogsResponse, err error) {
    return c.DescribeSearchLogsWithContext(context.Background(), request)
}

// DescribeSearchLogs
// This API is used to obtain historical search records.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeSearchLogsWithContext(ctx context.Context, request *DescribeSearchLogsRequest) (response *DescribeSearchLogsResponse, err error) {
    if request == nil {
        request = NewDescribeSearchLogsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSearchLogs")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSearchLogs require credential")
    }

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

func NewDescribeSearchTemplatesRequest() (request *DescribeSearchTemplatesRequest) {
    request = &DescribeSearchTemplatesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSearchTemplates")
    
    
    return
}

func NewDescribeSearchTemplatesResponse() (response *DescribeSearchTemplatesResponse) {
    response = &DescribeSearchTemplatesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSearchTemplates
// This API is used to obtain the list of quick retrievals.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeSearchTemplates(request *DescribeSearchTemplatesRequest) (response *DescribeSearchTemplatesResponse, err error) {
    return c.DescribeSearchTemplatesWithContext(context.Background(), request)
}

// DescribeSearchTemplates
// This API is used to obtain the list of quick retrievals.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeSearchTemplatesWithContext(ctx context.Context, request *DescribeSearchTemplatesRequest) (response *DescribeSearchTemplatesResponse, err error) {
    if request == nil {
        request = NewDescribeSearchTemplatesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSearchTemplates")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSearchTemplates require credential")
    }

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

func NewDescribeSecurityBroadcastInfoRequest() (request *DescribeSecurityBroadcastInfoRequest) {
    request = &DescribeSecurityBroadcastInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityBroadcastInfo")
    
    
    return
}

func NewDescribeSecurityBroadcastInfoResponse() (response *DescribeSecurityBroadcastInfoResponse) {
    response = &DescribeSecurityBroadcastInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityBroadcastInfo
// This API is used to query the information of security report articles.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityBroadcastInfo(request *DescribeSecurityBroadcastInfoRequest) (response *DescribeSecurityBroadcastInfoResponse, err error) {
    return c.DescribeSecurityBroadcastInfoWithContext(context.Background(), request)
}

// DescribeSecurityBroadcastInfo
// This API is used to query the information of security report articles.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityBroadcastInfoWithContext(ctx context.Context, request *DescribeSecurityBroadcastInfoRequest) (response *DescribeSecurityBroadcastInfoResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityBroadcastInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityBroadcastInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityBroadcastInfo require credential")
    }

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

func NewDescribeSecurityBroadcastsRequest() (request *DescribeSecurityBroadcastsRequest) {
    request = &DescribeSecurityBroadcastsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityBroadcasts")
    
    
    return
}

func NewDescribeSecurityBroadcastsResponse() (response *DescribeSecurityBroadcastsResponse) {
    response = &DescribeSecurityBroadcastsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityBroadcasts
// This API is used to obtain the security report list page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) DescribeSecurityBroadcasts(request *DescribeSecurityBroadcastsRequest) (response *DescribeSecurityBroadcastsResponse, err error) {
    return c.DescribeSecurityBroadcastsWithContext(context.Background(), request)
}

// DescribeSecurityBroadcasts
// This API is used to obtain the security report list page.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
func (c *Client) DescribeSecurityBroadcastsWithContext(ctx context.Context, request *DescribeSecurityBroadcastsRequest) (response *DescribeSecurityBroadcastsResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityBroadcastsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityBroadcasts")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityBroadcasts require credential")
    }

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

func NewDescribeSecurityDynamicsRequest() (request *DescribeSecurityDynamicsRequest) {
    request = &DescribeSecurityDynamicsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityDynamics")
    
    
    return
}

func NewDescribeSecurityDynamicsResponse() (response *DescribeSecurityDynamicsResponse) {
    response = &DescribeSecurityDynamicsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityDynamics
// This API is used to obtain the dynamic message data of security events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeSecurityDynamics(request *DescribeSecurityDynamicsRequest) (response *DescribeSecurityDynamicsResponse, err error) {
    return c.DescribeSecurityDynamicsWithContext(context.Background(), request)
}

// DescribeSecurityDynamics
// This API is used to obtain the dynamic message data of security events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
func (c *Client) DescribeSecurityDynamicsWithContext(ctx context.Context, request *DescribeSecurityDynamicsRequest) (response *DescribeSecurityDynamicsResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityDynamicsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityDynamics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityDynamics require credential")
    }

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

func NewDescribeSecurityEventStatRequest() (request *DescribeSecurityEventStatRequest) {
    request = &DescribeSecurityEventStatRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityEventStat")
    
    
    return
}

func NewDescribeSecurityEventStatResponse() (response *DescribeSecurityEventStatResponse) {
    response = &DescribeSecurityEventStatResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityEventStat
// This API is used to obtain the statistics of security events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityEventStat(request *DescribeSecurityEventStatRequest) (response *DescribeSecurityEventStatResponse, err error) {
    return c.DescribeSecurityEventStatWithContext(context.Background(), request)
}

// DescribeSecurityEventStat
// This API is used to obtain the statistics of security events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityEventStatWithContext(ctx context.Context, request *DescribeSecurityEventStatRequest) (response *DescribeSecurityEventStatResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityEventStatRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityEventStat")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityEventStat require credential")
    }

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

func NewDescribeSecurityEventsCntRequest() (request *DescribeSecurityEventsCntRequest) {
    request = &DescribeSecurityEventsCntRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityEventsCnt")
    
    
    return
}

func NewDescribeSecurityEventsCntResponse() (response *DescribeSecurityEventsCntResponse) {
    response = &DescribeSecurityEventsCntResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityEventsCnt
// This API is used to obtain the statistics data of security overview-related events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityEventsCnt(request *DescribeSecurityEventsCntRequest) (response *DescribeSecurityEventsCntResponse, err error) {
    return c.DescribeSecurityEventsCntWithContext(context.Background(), request)
}

// DescribeSecurityEventsCnt
// This API is used to obtain the statistics data of security overview-related events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeSecurityEventsCntWithContext(ctx context.Context, request *DescribeSecurityEventsCntRequest) (response *DescribeSecurityEventsCntResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityEventsCntRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityEventsCnt")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityEventsCnt require credential")
    }

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

func NewDescribeSecurityProtectionStatRequest() (request *DescribeSecurityProtectionStatRequest) {
    request = &DescribeSecurityProtectionStatRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityProtectionStat")
    
    
    return
}

func NewDescribeSecurityProtectionStatResponse() (response *DescribeSecurityProtectionStatResponse) {
    response = &DescribeSecurityProtectionStatResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityProtectionStat
// 接口已无效
//
// 
//
// This API is used to obtain the summary of security protection statuses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeSecurityProtectionStat(request *DescribeSecurityProtectionStatRequest) (response *DescribeSecurityProtectionStatResponse, err error) {
    return c.DescribeSecurityProtectionStatWithContext(context.Background(), request)
}

// DescribeSecurityProtectionStat
// 接口已无效
//
// 
//
// This API is used to obtain the summary of security protection statuses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) DescribeSecurityProtectionStatWithContext(ctx context.Context, request *DescribeSecurityProtectionStatRequest) (response *DescribeSecurityProtectionStatResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityProtectionStatRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityProtectionStat")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityProtectionStat require credential")
    }

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

func NewDescribeSecurityTrendsRequest() (request *DescribeSecurityTrendsRequest) {
    request = &DescribeSecurityTrendsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeSecurityTrends")
    
    
    return
}

func NewDescribeSecurityTrendsResponse() (response *DescribeSecurityTrendsResponse) {
    response = &DescribeSecurityTrendsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeSecurityTrends
// This API is used to obtain the security event statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeSecurityTrends(request *DescribeSecurityTrendsRequest) (response *DescribeSecurityTrendsResponse, err error) {
    return c.DescribeSecurityTrendsWithContext(context.Background(), request)
}

// DescribeSecurityTrends
// This API is used to obtain the security event statistics data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeSecurityTrendsWithContext(ctx context.Context, request *DescribeSecurityTrendsRequest) (response *DescribeSecurityTrendsResponse, err error) {
    if request == nil {
        request = NewDescribeSecurityTrendsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeSecurityTrends")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeSecurityTrends require credential")
    }

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

func NewDescribeServersAndRiskAndFirstInfoRequest() (request *DescribeServersAndRiskAndFirstInfoRequest) {
    request = &DescribeServersAndRiskAndFirstInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeServersAndRiskAndFirstInfo")
    
    
    return
}

func NewDescribeServersAndRiskAndFirstInfoResponse() (response *DescribeServersAndRiskAndFirstInfoResponse) {
    response = &DescribeServersAndRiskAndFirstInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeServersAndRiskAndFirstInfo
// This API is used to obtain the number of risky files pending to be processed + the number of affected servers + whether to try to detect + last detection time.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeServersAndRiskAndFirstInfo(request *DescribeServersAndRiskAndFirstInfoRequest) (response *DescribeServersAndRiskAndFirstInfoResponse, err error) {
    return c.DescribeServersAndRiskAndFirstInfoWithContext(context.Background(), request)
}

// DescribeServersAndRiskAndFirstInfo
// This API is used to obtain the number of risky files pending to be processed + the number of affected servers + whether to try to detect + last detection time.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeServersAndRiskAndFirstInfoWithContext(ctx context.Context, request *DescribeServersAndRiskAndFirstInfoRequest) (response *DescribeServersAndRiskAndFirstInfoResponse, err error) {
    if request == nil {
        request = NewDescribeServersAndRiskAndFirstInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeServersAndRiskAndFirstInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeServersAndRiskAndFirstInfo require credential")
    }

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

func NewDescribeStrategyExistRequest() (request *DescribeStrategyExistRequest) {
    request = &DescribeStrategyExistRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeStrategyExist")
    
    
    return
}

func NewDescribeStrategyExistResponse() (response *DescribeStrategyExistResponse) {
    response = &DescribeStrategyExistResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeStrategyExist
// This API is used to query whether a policy exists by policy name.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeStrategyExist(request *DescribeStrategyExistRequest) (response *DescribeStrategyExistResponse, err error) {
    return c.DescribeStrategyExistWithContext(context.Background(), request)
}

// DescribeStrategyExist
// This API is used to query whether a policy exists by policy name.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeStrategyExistWithContext(ctx context.Context, request *DescribeStrategyExistRequest) (response *DescribeStrategyExistResponse, err error) {
    if request == nil {
        request = NewDescribeStrategyExistRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeStrategyExist")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeStrategyExist require credential")
    }

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

func NewDescribeTagMachinesRequest() (request *DescribeTagMachinesRequest) {
    request = &DescribeTagMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeTagMachines")
    
    
    return
}

func NewDescribeTagMachinesResponse() (response *DescribeTagMachinesResponse) {
    response = &DescribeTagMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTagMachines
// This API is used to obtain the server information associated with the specified tag.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTagMachines(request *DescribeTagMachinesRequest) (response *DescribeTagMachinesResponse, err error) {
    return c.DescribeTagMachinesWithContext(context.Background(), request)
}

// DescribeTagMachines
// This API is used to obtain the server information associated with the specified tag.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTagMachinesWithContext(ctx context.Context, request *DescribeTagMachinesRequest) (response *DescribeTagMachinesResponse, err error) {
    if request == nil {
        request = NewDescribeTagMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeTagMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTagMachines require credential")
    }

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

func NewDescribeTagsRequest() (request *DescribeTagsRequest) {
    request = &DescribeTagsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeTags")
    
    
    return
}

func NewDescribeTagsResponse() (response *DescribeTagsResponse) {
    response = &DescribeTagsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTags
// This API is used to obtain all host tags.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTags(request *DescribeTagsRequest) (response *DescribeTagsResponse, err error) {
    return c.DescribeTagsWithContext(context.Background(), request)
}

// DescribeTags
// This API is used to obtain all host tags.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTagsWithContext(ctx context.Context, request *DescribeTagsRequest) (response *DescribeTagsResponse, err error) {
    if request == nil {
        request = NewDescribeTagsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeTags")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTags require credential")
    }

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

func NewDescribeTrialReportRequest() (request *DescribeTrialReportRequest) {
    request = &DescribeTrialReportRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeTrialReport")
    
    
    return
}

func NewDescribeTrialReportResponse() (response *DescribeTrialReportResponse) {
    response = &DescribeTrialReportResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeTrialReport
// This API is used to query the CWPP authorized trial report (only available for console applications).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTrialReport(request *DescribeTrialReportRequest) (response *DescribeTrialReportResponse, err error) {
    return c.DescribeTrialReportWithContext(context.Background(), request)
}

// DescribeTrialReport
// This API is used to query the CWPP authorized trial report (only available for console applications).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeTrialReportWithContext(ctx context.Context, request *DescribeTrialReportRequest) (response *DescribeTrialReportResponse, err error) {
    if request == nil {
        request = NewDescribeTrialReportRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeTrialReport")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeTrialReport require credential")
    }

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

func NewDescribeUndoVulCountsRequest() (request *DescribeUndoVulCountsRequest) {
    request = &DescribeUndoVulCountsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeUndoVulCounts")
    
    
    return
}

func NewDescribeUndoVulCountsResponse() (response *DescribeUndoVulCountsResponse) {
    response = &DescribeUndoVulCountsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeUndoVulCounts
// This API is used to obtain the number of pending vulnerabilities of a specified category and the number of hosts in the vulnerability management module.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeUndoVulCounts(request *DescribeUndoVulCountsRequest) (response *DescribeUndoVulCountsResponse, err error) {
    return c.DescribeUndoVulCountsWithContext(context.Background(), request)
}

// DescribeUndoVulCounts
// This API is used to obtain the number of pending vulnerabilities of a specified category and the number of hosts in the vulnerability management module.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeUndoVulCountsWithContext(ctx context.Context, request *DescribeUndoVulCountsRequest) (response *DescribeUndoVulCountsResponse, err error) {
    if request == nil {
        request = NewDescribeUndoVulCountsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeUndoVulCounts")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeUndoVulCounts require credential")
    }

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

func NewDescribeUsersConfigRequest() (request *DescribeUsersConfigRequest) {
    request = &DescribeUsersConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeUsersConfig")
    
    
    return
}

func NewDescribeUsersConfigResponse() (response *DescribeUsersConfigResponse) {
    response = &DescribeUsersConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeUsersConfig
// This API is used to query the user's custom configurations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeUsersConfig(request *DescribeUsersConfigRequest) (response *DescribeUsersConfigResponse, err error) {
    return c.DescribeUsersConfigWithContext(context.Background(), request)
}

// DescribeUsersConfig
// This API is used to query the user's custom configurations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeUsersConfigWithContext(ctx context.Context, request *DescribeUsersConfigRequest) (response *DescribeUsersConfigResponse, err error) {
    if request == nil {
        request = NewDescribeUsersConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeUsersConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeUsersConfig require credential")
    }

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

func NewDescribeUsualLoginPlacesRequest() (request *DescribeUsualLoginPlacesRequest) {
    request = &DescribeUsualLoginPlacesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeUsualLoginPlaces")
    
    
    return
}

func NewDescribeUsualLoginPlacesResponse() (response *DescribeUsualLoginPlacesResponse) {
    response = &DescribeUsualLoginPlacesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeUsualLoginPlaces
// This API is used to query common log-in locations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeUsualLoginPlaces(request *DescribeUsualLoginPlacesRequest) (response *DescribeUsualLoginPlacesResponse, err error) {
    return c.DescribeUsualLoginPlacesWithContext(context.Background(), request)
}

// DescribeUsualLoginPlaces
// This API is used to query common log-in locations.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeUsualLoginPlacesWithContext(ctx context.Context, request *DescribeUsualLoginPlacesRequest) (response *DescribeUsualLoginPlacesResponse, err error) {
    if request == nil {
        request = NewDescribeUsualLoginPlacesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeUsualLoginPlaces")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeUsualLoginPlaces require credential")
    }

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

func NewDescribeVdbAndPocInfoRequest() (request *DescribeVdbAndPocInfoRequest) {
    request = &DescribeVdbAndPocInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVdbAndPocInfo")
    
    
    return
}

func NewDescribeVdbAndPocInfoResponse() (response *DescribeVdbAndPocInfoResponse) {
    response = &DescribeVdbAndPocInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVdbAndPocInfo
// This API is used to obtain virus database and POC updates.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVdbAndPocInfo(request *DescribeVdbAndPocInfoRequest) (response *DescribeVdbAndPocInfoResponse, err error) {
    return c.DescribeVdbAndPocInfoWithContext(context.Background(), request)
}

// DescribeVdbAndPocInfo
// This API is used to obtain virus database and POC updates.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVdbAndPocInfoWithContext(ctx context.Context, request *DescribeVdbAndPocInfoRequest) (response *DescribeVdbAndPocInfoResponse, err error) {
    if request == nil {
        request = NewDescribeVdbAndPocInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVdbAndPocInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVdbAndPocInfo require credential")
    }

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

func NewDescribeVersionCompareChartRequest() (request *DescribeVersionCompareChartRequest) {
    request = &DescribeVersionCompareChartRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVersionCompareChart")
    
    
    return
}

func NewDescribeVersionCompareChartResponse() (response *DescribeVersionCompareChartResponse) {
    response = &DescribeVersionCompareChartResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVersionCompareChart
// This API is used to obtain the version comparison information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVersionCompareChart(request *DescribeVersionCompareChartRequest) (response *DescribeVersionCompareChartResponse, err error) {
    return c.DescribeVersionCompareChartWithContext(context.Background(), request)
}

// DescribeVersionCompareChart
// This API is used to obtain the version comparison information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVersionCompareChartWithContext(ctx context.Context, request *DescribeVersionCompareChartRequest) (response *DescribeVersionCompareChartResponse, err error) {
    if request == nil {
        request = NewDescribeVersionCompareChartRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVersionCompareChart")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVersionCompareChart require credential")
    }

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

func NewDescribeVersionStatisticsRequest() (request *DescribeVersionStatisticsRequest) {
    request = &DescribeVersionStatisticsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVersionStatistics")
    
    
    return
}

func NewDescribeVersionStatisticsResponse() (response *DescribeVersionStatisticsResponse) {
    response = &DescribeVersionStatisticsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVersionStatistics
// This API is used to count the number of machines of Professional and Basic editions.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVersionStatistics(request *DescribeVersionStatisticsRequest) (response *DescribeVersionStatisticsResponse, err error) {
    return c.DescribeVersionStatisticsWithContext(context.Background(), request)
}

// DescribeVersionStatistics
// This API is used to count the number of machines of Professional and Basic editions.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVersionStatisticsWithContext(ctx context.Context, request *DescribeVersionStatisticsRequest) (response *DescribeVersionStatisticsResponse, err error) {
    if request == nil {
        request = NewDescribeVersionStatisticsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVersionStatistics")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVersionStatistics require credential")
    }

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

func NewDescribeVertexDetailRequest() (request *DescribeVertexDetailRequest) {
    request = &DescribeVertexDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVertexDetail")
    
    
    return
}

func NewDescribeVertexDetailResponse() (response *DescribeVertexDetailResponse) {
    response = &DescribeVertexDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVertexDetail
// This API is used to obtain the attribute information of the specified point.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVertexDetail(request *DescribeVertexDetailRequest) (response *DescribeVertexDetailResponse, err error) {
    return c.DescribeVertexDetailWithContext(context.Background(), request)
}

// DescribeVertexDetail
// This API is used to obtain the attribute information of the specified point.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVertexDetailWithContext(ctx context.Context, request *DescribeVertexDetailRequest) (response *DescribeVertexDetailResponse, err error) {
    if request == nil {
        request = NewDescribeVertexDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVertexDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVertexDetail require credential")
    }

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

func NewDescribeVulCountByDatesRequest() (request *DescribeVulCountByDatesRequest) {
    request = &DescribeVulCountByDatesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulCountByDates")
    
    
    return
}

func NewDescribeVulCountByDatesResponse() (response *DescribeVulCountByDatesResponse) {
    response = &DescribeVulCountByDatesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulCountByDates
// This API is used to obtain the number of vulnerabilities of specified types in recent days and the number of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulCountByDates(request *DescribeVulCountByDatesRequest) (response *DescribeVulCountByDatesResponse, err error) {
    return c.DescribeVulCountByDatesWithContext(context.Background(), request)
}

// DescribeVulCountByDates
// This API is used to obtain the number of vulnerabilities of specified types in recent days and the number of hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulCountByDatesWithContext(ctx context.Context, request *DescribeVulCountByDatesRequest) (response *DescribeVulCountByDatesResponse, err error) {
    if request == nil {
        request = NewDescribeVulCountByDatesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulCountByDates")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulCountByDates require credential")
    }

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

func NewDescribeVulCveIdInfoRequest() (request *DescribeVulCveIdInfoRequest) {
    request = &DescribeVulCveIdInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulCveIdInfo")
    
    
    return
}

func NewDescribeVulCveIdInfoResponse() (response *DescribeVulCveIdInfoResponse) {
    response = &DescribeVulCveIdInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulCveIdInfo
// This API is used to query vulnerability details by CveId.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulCveIdInfo(request *DescribeVulCveIdInfoRequest) (response *DescribeVulCveIdInfoResponse, err error) {
    return c.DescribeVulCveIdInfoWithContext(context.Background(), request)
}

// DescribeVulCveIdInfo
// This API is used to query vulnerability details by CveId.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulCveIdInfoWithContext(ctx context.Context, request *DescribeVulCveIdInfoRequest) (response *DescribeVulCveIdInfoResponse, err error) {
    if request == nil {
        request = NewDescribeVulCveIdInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulCveIdInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulCveIdInfo require credential")
    }

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

func NewDescribeVulDefenceEventRequest() (request *DescribeVulDefenceEventRequest) {
    request = &DescribeVulDefenceEventRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefenceEvent")
    
    
    return
}

func NewDescribeVulDefenceEventResponse() (response *DescribeVulDefenceEventResponse) {
    response = &DescribeVulDefenceEventResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefenceEvent
// This API is used to obtain the list of vulnerability defense events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceEvent(request *DescribeVulDefenceEventRequest) (response *DescribeVulDefenceEventResponse, err error) {
    return c.DescribeVulDefenceEventWithContext(context.Background(), request)
}

// DescribeVulDefenceEvent
// This API is used to obtain the list of vulnerability defense events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceEventWithContext(ctx context.Context, request *DescribeVulDefenceEventRequest) (response *DescribeVulDefenceEventResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefenceEventRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefenceEvent")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefenceEvent require credential")
    }

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

func NewDescribeVulDefenceListRequest() (request *DescribeVulDefenceListRequest) {
    request = &DescribeVulDefenceListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefenceList")
    
    
    return
}

func NewDescribeVulDefenceListResponse() (response *DescribeVulDefenceListResponse) {
    response = &DescribeVulDefenceListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefenceList
// This API is used to query the vulnerability defense list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceList(request *DescribeVulDefenceListRequest) (response *DescribeVulDefenceListResponse, err error) {
    return c.DescribeVulDefenceListWithContext(context.Background(), request)
}

// DescribeVulDefenceList
// This API is used to query the vulnerability defense list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceListWithContext(ctx context.Context, request *DescribeVulDefenceListRequest) (response *DescribeVulDefenceListResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefenceListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefenceList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefenceList require credential")
    }

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

func NewDescribeVulDefenceOverviewRequest() (request *DescribeVulDefenceOverviewRequest) {
    request = &DescribeVulDefenceOverviewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefenceOverview")
    
    
    return
}

func NewDescribeVulDefenceOverviewResponse() (response *DescribeVulDefenceOverviewResponse) {
    response = &DescribeVulDefenceOverviewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefenceOverview
// This API is used to obtain the vulnerability defense overview information, including event trend and plugin enabling status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceOverview(request *DescribeVulDefenceOverviewRequest) (response *DescribeVulDefenceOverviewResponse, err error) {
    return c.DescribeVulDefenceOverviewWithContext(context.Background(), request)
}

// DescribeVulDefenceOverview
// This API is used to obtain the vulnerability defense overview information, including event trend and plugin enabling status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulDefenceOverviewWithContext(ctx context.Context, request *DescribeVulDefenceOverviewRequest) (response *DescribeVulDefenceOverviewResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefenceOverviewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefenceOverview")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefenceOverview require credential")
    }

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

func NewDescribeVulDefencePluginDetailRequest() (request *DescribeVulDefencePluginDetailRequest) {
    request = &DescribeVulDefencePluginDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefencePluginDetail")
    
    
    return
}

func NewDescribeVulDefencePluginDetailResponse() (response *DescribeVulDefencePluginDetailResponse) {
    response = &DescribeVulDefencePluginDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefencePluginDetail
// This API is used to obtain the vulnerability defense plugin information on a single host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginDetail(request *DescribeVulDefencePluginDetailRequest) (response *DescribeVulDefencePluginDetailResponse, err error) {
    return c.DescribeVulDefencePluginDetailWithContext(context.Background(), request)
}

// DescribeVulDefencePluginDetail
// This API is used to obtain the vulnerability defense plugin information on a single host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginDetailWithContext(ctx context.Context, request *DescribeVulDefencePluginDetailRequest) (response *DescribeVulDefencePluginDetailResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefencePluginDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefencePluginDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefencePluginDetail require credential")
    }

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

func NewDescribeVulDefencePluginExceptionCountRequest() (request *DescribeVulDefencePluginExceptionCountRequest) {
    request = &DescribeVulDefencePluginExceptionCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefencePluginExceptionCount")
    
    
    return
}

func NewDescribeVulDefencePluginExceptionCountResponse() (response *DescribeVulDefencePluginExceptionCountResponse) {
    response = &DescribeVulDefencePluginExceptionCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefencePluginExceptionCount
// This API is used to obtain the current number of abnormal plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginExceptionCount(request *DescribeVulDefencePluginExceptionCountRequest) (response *DescribeVulDefencePluginExceptionCountResponse, err error) {
    return c.DescribeVulDefencePluginExceptionCountWithContext(context.Background(), request)
}

// DescribeVulDefencePluginExceptionCount
// This API is used to obtain the current number of abnormal plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginExceptionCountWithContext(ctx context.Context, request *DescribeVulDefencePluginExceptionCountRequest) (response *DescribeVulDefencePluginExceptionCountResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefencePluginExceptionCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefencePluginExceptionCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefencePluginExceptionCount require credential")
    }

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

func NewDescribeVulDefencePluginStatusRequest() (request *DescribeVulDefencePluginStatusRequest) {
    request = &DescribeVulDefencePluginStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefencePluginStatus")
    
    
    return
}

func NewDescribeVulDefencePluginStatusResponse() (response *DescribeVulDefencePluginStatusResponse) {
    response = &DescribeVulDefencePluginStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefencePluginStatus
// This API is used to obtain the vulnerability defense plugin status of each host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginStatus(request *DescribeVulDefencePluginStatusRequest) (response *DescribeVulDefencePluginStatusResponse, err error) {
    return c.DescribeVulDefencePluginStatusWithContext(context.Background(), request)
}

// DescribeVulDefencePluginStatus
// This API is used to obtain the vulnerability defense plugin status of each host.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefencePluginStatusWithContext(ctx context.Context, request *DescribeVulDefencePluginStatusRequest) (response *DescribeVulDefencePluginStatusResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefencePluginStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefencePluginStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefencePluginStatus require credential")
    }

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

func NewDescribeVulDefenceSettingRequest() (request *DescribeVulDefenceSettingRequest) {
    request = &DescribeVulDefenceSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulDefenceSetting")
    
    
    return
}

func NewDescribeVulDefenceSettingResponse() (response *DescribeVulDefenceSettingResponse) {
    response = &DescribeVulDefenceSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulDefenceSetting
// This API is used to obtain the current vulnerability defense plugin settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefenceSetting(request *DescribeVulDefenceSettingRequest) (response *DescribeVulDefenceSettingResponse, err error) {
    return c.DescribeVulDefenceSettingWithContext(context.Background(), request)
}

// DescribeVulDefenceSetting
// This API is used to obtain the current vulnerability defense plugin settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulDefenceSettingWithContext(ctx context.Context, request *DescribeVulDefenceSettingRequest) (response *DescribeVulDefenceSettingResponse, err error) {
    if request == nil {
        request = NewDescribeVulDefenceSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulDefenceSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulDefenceSetting require credential")
    }

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

func NewDescribeVulEffectHostListRequest() (request *DescribeVulEffectHostListRequest) {
    request = &DescribeVulEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulEffectHostList")
    
    
    return
}

func NewDescribeVulEffectHostListResponse() (response *DescribeVulEffectHostListResponse) {
    response = &DescribeVulEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulEffectHostList
// This API is used to obtain the list of hosts affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulEffectHostList(request *DescribeVulEffectHostListRequest) (response *DescribeVulEffectHostListResponse, err error) {
    return c.DescribeVulEffectHostListWithContext(context.Background(), request)
}

// DescribeVulEffectHostList
// This API is used to obtain the list of hosts affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulEffectHostListWithContext(ctx context.Context, request *DescribeVulEffectHostListRequest) (response *DescribeVulEffectHostListResponse, err error) {
    if request == nil {
        request = NewDescribeVulEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulEffectHostList require credential")
    }

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

func NewDescribeVulEffectModulesRequest() (request *DescribeVulEffectModulesRequest) {
    request = &DescribeVulEffectModulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulEffectModules")
    
    
    return
}

func NewDescribeVulEffectModulesResponse() (response *DescribeVulEffectModulesResponse) {
    response = &DescribeVulEffectModulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulEffectModules
// This API is used to obtain the list of components affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulEffectModules(request *DescribeVulEffectModulesRequest) (response *DescribeVulEffectModulesResponse, err error) {
    return c.DescribeVulEffectModulesWithContext(context.Background(), request)
}

// DescribeVulEffectModules
// This API is used to obtain the list of components affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulEffectModulesWithContext(ctx context.Context, request *DescribeVulEffectModulesRequest) (response *DescribeVulEffectModulesResponse, err error) {
    if request == nil {
        request = NewDescribeVulEffectModulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulEffectModules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulEffectModules require credential")
    }

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

func NewDescribeVulEmergentMsgRequest() (request *DescribeVulEmergentMsgRequest) {
    request = &DescribeVulEmergentMsgRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulEmergentMsg")
    
    
    return
}

func NewDescribeVulEmergentMsgResponse() (response *DescribeVulEmergentMsgResponse) {
    response = &DescribeVulEmergentMsgResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulEmergentMsg
// This API is used to obtain vulnerability emergency notifications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulEmergentMsg(request *DescribeVulEmergentMsgRequest) (response *DescribeVulEmergentMsgResponse, err error) {
    return c.DescribeVulEmergentMsgWithContext(context.Background(), request)
}

// DescribeVulEmergentMsg
// This API is used to obtain vulnerability emergency notifications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulEmergentMsgWithContext(ctx context.Context, request *DescribeVulEmergentMsgRequest) (response *DescribeVulEmergentMsgResponse, err error) {
    if request == nil {
        request = NewDescribeVulEmergentMsgRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulEmergentMsg")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulEmergentMsg require credential")
    }

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

func NewDescribeVulFixStatusRequest() (request *DescribeVulFixStatusRequest) {
    request = &DescribeVulFixStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulFixStatus")
    
    
    return
}

func NewDescribeVulFixStatusResponse() (response *DescribeVulFixStatusResponse) {
    response = &DescribeVulFixStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulFixStatus
// This API is used to check the host vulnerability fixing progress.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulFixStatus(request *DescribeVulFixStatusRequest) (response *DescribeVulFixStatusResponse, err error) {
    return c.DescribeVulFixStatusWithContext(context.Background(), request)
}

// DescribeVulFixStatus
// This API is used to check the host vulnerability fixing progress.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulFixStatusWithContext(ctx context.Context, request *DescribeVulFixStatusRequest) (response *DescribeVulFixStatusResponse, err error) {
    if request == nil {
        request = NewDescribeVulFixStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulFixStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulFixStatus require credential")
    }

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

func NewDescribeVulHostCountScanTimeRequest() (request *DescribeVulHostCountScanTimeRequest) {
    request = &DescribeVulHostCountScanTimeRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulHostCountScanTime")
    
    
    return
}

func NewDescribeVulHostCountScanTimeResponse() (response *DescribeVulHostCountScanTimeResponse) {
    response = &DescribeVulHostCountScanTimeResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulHostCountScanTime
// This API is used to obtain the number of vulnerabilities pending to be processed and affected hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulHostCountScanTime(request *DescribeVulHostCountScanTimeRequest) (response *DescribeVulHostCountScanTimeResponse, err error) {
    return c.DescribeVulHostCountScanTimeWithContext(context.Background(), request)
}

// DescribeVulHostCountScanTime
// This API is used to obtain the number of vulnerabilities pending to be processed and affected hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulHostCountScanTimeWithContext(ctx context.Context, request *DescribeVulHostCountScanTimeRequest) (response *DescribeVulHostCountScanTimeResponse, err error) {
    if request == nil {
        request = NewDescribeVulHostCountScanTimeRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulHostCountScanTime")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulHostCountScanTime require credential")
    }

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

func NewDescribeVulHostTopRequest() (request *DescribeVulHostTopRequest) {
    request = &DescribeVulHostTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulHostTop")
    
    
    return
}

func NewDescribeVulHostTopResponse() (response *DescribeVulHostTopResponse) {
    response = &DescribeVulHostTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulHostTop
// This API is used to obtain the list of top server risks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulHostTop(request *DescribeVulHostTopRequest) (response *DescribeVulHostTopResponse, err error) {
    return c.DescribeVulHostTopWithContext(context.Background(), request)
}

// DescribeVulHostTop
// This API is used to obtain the list of top server risks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulHostTopWithContext(ctx context.Context, request *DescribeVulHostTopRequest) (response *DescribeVulHostTopResponse, err error) {
    if request == nil {
        request = NewDescribeVulHostTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulHostTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulHostTop require credential")
    }

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

func NewDescribeVulInfoCvssRequest() (request *DescribeVulInfoCvssRequest) {
    request = &DescribeVulInfoCvssRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulInfoCvss")
    
    
    return
}

func NewDescribeVulInfoCvssResponse() (response *DescribeVulInfoCvssResponse) {
    response = &DescribeVulInfoCvssResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulInfoCvss
// This API is used to obtain vulnerability details with the CVSS version.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulInfoCvss(request *DescribeVulInfoCvssRequest) (response *DescribeVulInfoCvssResponse, err error) {
    return c.DescribeVulInfoCvssWithContext(context.Background(), request)
}

// DescribeVulInfoCvss
// This API is used to obtain vulnerability details with the CVSS version.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulInfoCvssWithContext(ctx context.Context, request *DescribeVulInfoCvssRequest) (response *DescribeVulInfoCvssResponse, err error) {
    if request == nil {
        request = NewDescribeVulInfoCvssRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulInfoCvss")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulInfoCvss require credential")
    }

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

func NewDescribeVulLabelsRequest() (request *DescribeVulLabelsRequest) {
    request = &DescribeVulLabelsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulLabels")
    
    
    return
}

func NewDescribeVulLabelsResponse() (response *DescribeVulLabelsResponse) {
    response = &DescribeVulLabelsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulLabels
// This API is used to obtain the list of all user vulnerability tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulLabels(request *DescribeVulLabelsRequest) (response *DescribeVulLabelsResponse, err error) {
    return c.DescribeVulLabelsWithContext(context.Background(), request)
}

// DescribeVulLabels
// This API is used to obtain the list of all user vulnerability tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulLabelsWithContext(ctx context.Context, request *DescribeVulLabelsRequest) (response *DescribeVulLabelsResponse, err error) {
    if request == nil {
        request = NewDescribeVulLabelsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulLabels")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulLabels require credential")
    }

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

func NewDescribeVulLevelCountRequest() (request *DescribeVulLevelCountRequest) {
    request = &DescribeVulLevelCountRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulLevelCount")
    
    
    return
}

func NewDescribeVulLevelCountResponse() (response *DescribeVulLevelCountResponse) {
    response = &DescribeVulLevelCountResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulLevelCount
// This API is used to obtain the statistics of vulnerability quantity and level distribution.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulLevelCount(request *DescribeVulLevelCountRequest) (response *DescribeVulLevelCountResponse, err error) {
    return c.DescribeVulLevelCountWithContext(context.Background(), request)
}

// DescribeVulLevelCount
// This API is used to obtain the statistics of vulnerability quantity and level distribution.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeVulLevelCountWithContext(ctx context.Context, request *DescribeVulLevelCountRequest) (response *DescribeVulLevelCountResponse, err error) {
    if request == nil {
        request = NewDescribeVulLevelCountRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulLevelCount")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulLevelCount require credential")
    }

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

func NewDescribeVulListRequest() (request *DescribeVulListRequest) {
    request = &DescribeVulListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulList")
    
    
    return
}

func NewDescribeVulListResponse() (response *DescribeVulListResponse) {
    response = &DescribeVulListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulList
// This API is used to obtain the data of the vulnerability list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulList(request *DescribeVulListRequest) (response *DescribeVulListResponse, err error) {
    return c.DescribeVulListWithContext(context.Background(), request)
}

// DescribeVulList
// This API is used to obtain the data of the vulnerability list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulListWithContext(ctx context.Context, request *DescribeVulListRequest) (response *DescribeVulListResponse, err error) {
    if request == nil {
        request = NewDescribeVulListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulList require credential")
    }

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

func NewDescribeVulOverviewRequest() (request *DescribeVulOverviewRequest) {
    request = &DescribeVulOverviewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulOverview")
    
    
    return
}

func NewDescribeVulOverviewResponse() (response *DescribeVulOverviewResponse) {
    response = &DescribeVulOverviewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulOverview
// This API is used to obtain the data for the vulnerability overview.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulOverview(request *DescribeVulOverviewRequest) (response *DescribeVulOverviewResponse, err error) {
    return c.DescribeVulOverviewWithContext(context.Background(), request)
}

// DescribeVulOverview
// This API is used to obtain the data for the vulnerability overview.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) DescribeVulOverviewWithContext(ctx context.Context, request *DescribeVulOverviewRequest) (response *DescribeVulOverviewResponse, err error) {
    if request == nil {
        request = NewDescribeVulOverviewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulOverview")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulOverview require credential")
    }

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

func NewDescribeVulStoreListRequest() (request *DescribeVulStoreListRequest) {
    request = &DescribeVulStoreListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulStoreList")
    
    
    return
}

func NewDescribeVulStoreListResponse() (response *DescribeVulStoreListResponse) {
    response = &DescribeVulStoreListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulStoreList
// This API is used to obtain the vulnerability database list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeVulStoreList(request *DescribeVulStoreListRequest) (response *DescribeVulStoreListResponse, err error) {
    return c.DescribeVulStoreListWithContext(context.Background(), request)
}

// DescribeVulStoreList
// This API is used to obtain the vulnerability database list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) DescribeVulStoreListWithContext(ctx context.Context, request *DescribeVulStoreListRequest) (response *DescribeVulStoreListResponse, err error) {
    if request == nil {
        request = NewDescribeVulStoreListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulStoreList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulStoreList require credential")
    }

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

func NewDescribeVulTopRequest() (request *DescribeVulTopRequest) {
    request = &DescribeVulTopRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulTop")
    
    
    return
}

func NewDescribeVulTopResponse() (response *DescribeVulTopResponse) {
    response = &DescribeVulTopResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulTop
// This API is used to count top vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulTop(request *DescribeVulTopRequest) (response *DescribeVulTopResponse, err error) {
    return c.DescribeVulTopWithContext(context.Background(), request)
}

// DescribeVulTop
// This API is used to count top vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) DescribeVulTopWithContext(ctx context.Context, request *DescribeVulTopRequest) (response *DescribeVulTopResponse, err error) {
    if request == nil {
        request = NewDescribeVulTopRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulTop")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulTop require credential")
    }

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

func NewDescribeVulTrendRequest() (request *DescribeVulTrendRequest) {
    request = &DescribeVulTrendRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeVulTrend")
    
    
    return
}

func NewDescribeVulTrendResponse() (response *DescribeVulTrendResponse) {
    response = &DescribeVulTrendResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeVulTrend
// This API is used to obtain information of the vulnerability situation.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulTrend(request *DescribeVulTrendRequest) (response *DescribeVulTrendResponse, err error) {
    return c.DescribeVulTrendWithContext(context.Background(), request)
}

// DescribeVulTrend
// This API is used to obtain information of the vulnerability situation.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeVulTrendWithContext(ctx context.Context, request *DescribeVulTrendRequest) (response *DescribeVulTrendResponse, err error) {
    if request == nil {
        request = NewDescribeVulTrendRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeVulTrend")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeVulTrend require credential")
    }

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

func NewDescribeWarningHostConfigRequest() (request *DescribeWarningHostConfigRequest) {
    request = &DescribeWarningHostConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWarningHostConfig")
    
    
    return
}

func NewDescribeWarningHostConfigResponse() (response *DescribeWarningHostConfigResponse) {
    response = &DescribeWarningHostConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWarningHostConfig
// This API is used to query the alarming machine scope settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWarningHostConfig(request *DescribeWarningHostConfigRequest) (response *DescribeWarningHostConfigResponse, err error) {
    return c.DescribeWarningHostConfigWithContext(context.Background(), request)
}

// DescribeWarningHostConfig
// This API is used to query the alarming machine scope settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWarningHostConfigWithContext(ctx context.Context, request *DescribeWarningHostConfigRequest) (response *DescribeWarningHostConfigResponse, err error) {
    if request == nil {
        request = NewDescribeWarningHostConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWarningHostConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWarningHostConfig require credential")
    }

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

func NewDescribeWarningListRequest() (request *DescribeWarningListRequest) {
    request = &DescribeWarningListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWarningList")
    
    
    return
}

func NewDescribeWarningListResponse() (response *DescribeWarningListResponse) {
    response = &DescribeWarningListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWarningList
// This API is used to obtain the list of the current user's alarms.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWarningList(request *DescribeWarningListRequest) (response *DescribeWarningListResponse, err error) {
    return c.DescribeWarningListWithContext(context.Background(), request)
}

// DescribeWarningList
// This API is used to obtain the list of the current user's alarms.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWarningListWithContext(ctx context.Context, request *DescribeWarningListRequest) (response *DescribeWarningListResponse, err error) {
    if request == nil {
        request = NewDescribeWarningListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWarningList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWarningList require credential")
    }

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

func NewDescribeWebHookPolicyRequest() (request *DescribeWebHookPolicyRequest) {
    request = &DescribeWebHookPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWebHookPolicy")
    
    
    return
}

func NewDescribeWebHookPolicyResponse() (response *DescribeWebHookPolicyResponse) {
    response = &DescribeWebHookPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWebHookPolicy
// This API is used to query alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookPolicy(request *DescribeWebHookPolicyRequest) (response *DescribeWebHookPolicyResponse, err error) {
    return c.DescribeWebHookPolicyWithContext(context.Background(), request)
}

// DescribeWebHookPolicy
// This API is used to query alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookPolicyWithContext(ctx context.Context, request *DescribeWebHookPolicyRequest) (response *DescribeWebHookPolicyResponse, err error) {
    if request == nil {
        request = NewDescribeWebHookPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWebHookPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWebHookPolicy require credential")
    }

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

func NewDescribeWebHookReceiverRequest() (request *DescribeWebHookReceiverRequest) {
    request = &DescribeWebHookReceiverRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWebHookReceiver")
    
    
    return
}

func NewDescribeWebHookReceiverResponse() (response *DescribeWebHookReceiverResponse) {
    response = &DescribeWebHookReceiverResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWebHookReceiver
// This API is used to query the list of alarm recipients.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookReceiver(request *DescribeWebHookReceiverRequest) (response *DescribeWebHookReceiverResponse, err error) {
    return c.DescribeWebHookReceiverWithContext(context.Background(), request)
}

// DescribeWebHookReceiver
// This API is used to query the list of alarm recipients.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookReceiverWithContext(ctx context.Context, request *DescribeWebHookReceiverRequest) (response *DescribeWebHookReceiverResponse, err error) {
    if request == nil {
        request = NewDescribeWebHookReceiverRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWebHookReceiver")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWebHookReceiver require credential")
    }

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

func NewDescribeWebHookReceiverUsageRequest() (request *DescribeWebHookReceiverUsageRequest) {
    request = &DescribeWebHookReceiverUsageRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWebHookReceiverUsage")
    
    
    return
}

func NewDescribeWebHookReceiverUsageResponse() (response *DescribeWebHookReceiverUsageResponse) {
    response = &DescribeWebHookReceiverUsageResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWebHookReceiverUsage
// This API is used to query the usage of policies associated with the specified alarm recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookReceiverUsage(request *DescribeWebHookReceiverUsageRequest) (response *DescribeWebHookReceiverUsageResponse, err error) {
    return c.DescribeWebHookReceiverUsageWithContext(context.Background(), request)
}

// DescribeWebHookReceiverUsage
// This API is used to query the usage of policies associated with the specified alarm recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) DescribeWebHookReceiverUsageWithContext(ctx context.Context, request *DescribeWebHookReceiverUsageRequest) (response *DescribeWebHookReceiverUsageResponse, err error) {
    if request == nil {
        request = NewDescribeWebHookReceiverUsageRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWebHookReceiverUsage")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWebHookReceiverUsage require credential")
    }

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

func NewDescribeWebHookRuleRequest() (request *DescribeWebHookRuleRequest) {
    request = &DescribeWebHookRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWebHookRule")
    
    
    return
}

func NewDescribeWebHookRuleResponse() (response *DescribeWebHookRuleResponse) {
    response = &DescribeWebHookRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWebHookRule
// This API is used to obtain the details of the WeCom chatbot rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWebHookRule(request *DescribeWebHookRuleRequest) (response *DescribeWebHookRuleResponse, err error) {
    return c.DescribeWebHookRuleWithContext(context.Background(), request)
}

// DescribeWebHookRule
// This API is used to obtain the details of the WeCom chatbot rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWebHookRuleWithContext(ctx context.Context, request *DescribeWebHookRuleRequest) (response *DescribeWebHookRuleResponse, err error) {
    if request == nil {
        request = NewDescribeWebHookRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWebHookRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWebHookRule require credential")
    }

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

func NewDescribeWebHookRulesRequest() (request *DescribeWebHookRulesRequest) {
    request = &DescribeWebHookRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DescribeWebHookRules")
    
    
    return
}

func NewDescribeWebHookRulesResponse() (response *DescribeWebHookRulesResponse) {
    response = &DescribeWebHookRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DescribeWebHookRules
// This API is used to obtain the list of WeCom chatbot rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWebHookRules(request *DescribeWebHookRulesRequest) (response *DescribeWebHookRulesResponse, err error) {
    return c.DescribeWebHookRulesWithContext(context.Background(), request)
}

// DescribeWebHookRules
// This API is used to obtain the list of WeCom chatbot rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DescribeWebHookRulesWithContext(ctx context.Context, request *DescribeWebHookRulesRequest) (response *DescribeWebHookRulesResponse, err error) {
    if request == nil {
        request = NewDescribeWebHookRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DescribeWebHookRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DescribeWebHookRules require credential")
    }

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

func NewDestroyOrderRequest() (request *DestroyOrderRequest) {
    request = &DestroyOrderRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "DestroyOrder")
    
    
    return
}

func NewDestroyOrderResponse() (response *DestroyOrderResponse) {
    response = &DestroyOrderResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// DestroyOrder
// This API is used to terminate resources.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DestroyOrder(request *DestroyOrderRequest) (response *DestroyOrderResponse, err error) {
    return c.DestroyOrderWithContext(context.Background(), request)
}

// DestroyOrder
// This API is used to terminate resources.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) DestroyOrderWithContext(ctx context.Context, request *DestroyOrderRequest) (response *DestroyOrderResponse, err error) {
    if request == nil {
        request = NewDestroyOrderRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "DestroyOrder")
    
    if c.GetCredential() == nil {
        return nil, errors.New("DestroyOrder require credential")
    }

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

func NewEditBashRulesRequest() (request *EditBashRulesRequest) {
    request = &EditBashRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "EditBashRules")
    
    
    return
}

func NewEditBashRulesResponse() (response *EditBashRulesResponse) {
    response = &EditBashRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// EditBashRules
// This API is used to add or modify high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditBashRules(request *EditBashRulesRequest) (response *EditBashRulesResponse, err error) {
    return c.EditBashRulesWithContext(context.Background(), request)
}

// EditBashRules
// This API is used to add or modify high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditBashRulesWithContext(ctx context.Context, request *EditBashRulesRequest) (response *EditBashRulesResponse, err error) {
    if request == nil {
        request = NewEditBashRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "EditBashRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("EditBashRules require credential")
    }

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

func NewEditPrivilegeRulesRequest() (request *EditPrivilegeRulesRequest) {
    request = &EditPrivilegeRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "EditPrivilegeRules")
    
    
    return
}

func NewEditPrivilegeRulesResponse() (response *EditPrivilegeRulesResponse) {
    response = &EditPrivilegeRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// EditPrivilegeRules
// This API is used to add or modify local privilege escalation rules (multiple servers supported).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditPrivilegeRules(request *EditPrivilegeRulesRequest) (response *EditPrivilegeRulesResponse, err error) {
    return c.EditPrivilegeRulesWithContext(context.Background(), request)
}

// EditPrivilegeRules
// This API is used to add or modify local privilege escalation rules (multiple servers supported).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditPrivilegeRulesWithContext(ctx context.Context, request *EditPrivilegeRulesRequest) (response *EditPrivilegeRulesResponse, err error) {
    if request == nil {
        request = NewEditPrivilegeRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "EditPrivilegeRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("EditPrivilegeRules require credential")
    }

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

func NewEditReverseShellRulesRequest() (request *EditReverseShellRulesRequest) {
    request = &EditReverseShellRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "EditReverseShellRules")
    
    
    return
}

func NewEditReverseShellRulesResponse() (response *EditReverseShellRulesResponse) {
    response = &EditReverseShellRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// EditReverseShellRules
// This API is used to edit reverse shell rules (multiple servers supported).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_PORTNOVALID = "InvalidParameter.PortNoValid"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_REVERSHELLKEYFIELDALLEMPTY = "InvalidParameter.ReverShellKeyFieldAllEmpty"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditReverseShellRules(request *EditReverseShellRulesRequest) (response *EditReverseShellRulesResponse, err error) {
    return c.EditReverseShellRulesWithContext(context.Background(), request)
}

// EditReverseShellRules
// This API is used to edit reverse shell rules (multiple servers supported).
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_PORTNOVALID = "InvalidParameter.PortNoValid"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_REVERSHELLKEYFIELDALLEMPTY = "InvalidParameter.ReverShellKeyFieldAllEmpty"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditReverseShellRulesWithContext(ctx context.Context, request *EditReverseShellRulesRequest) (response *EditReverseShellRulesResponse, err error) {
    if request == nil {
        request = NewEditReverseShellRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "EditReverseShellRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("EditReverseShellRules require credential")
    }

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

func NewEditTagsRequest() (request *EditTagsRequest) {
    request = &EditTagsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "EditTags")
    
    
    return
}

func NewEditTagsResponse() (response *EditTagsResponse) {
    response = &EditTagsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// EditTags
// This API is used to add or edit tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_TAGNAMELENGTHLIMIT = "InvalidParameterValue.TagNameLengthLimit"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditTags(request *EditTagsRequest) (response *EditTagsResponse, err error) {
    return c.EditTagsWithContext(context.Background(), request)
}

// EditTags
// This API is used to add or edit tags.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  INVALIDPARAMETERVALUE_TAGNAMELENGTHLIMIT = "InvalidParameterValue.TagNameLengthLimit"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) EditTagsWithContext(ctx context.Context, request *EditTagsRequest) (response *EditTagsResponse, err error) {
    if request == nil {
        request = NewEditTagsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "EditTags")
    
    if c.GetCredential() == nil {
        return nil, errors.New("EditTags require credential")
    }

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

func NewExportAssetAppListRequest() (request *ExportAssetAppListRequest) {
    request = &ExportAssetAppListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetAppList")
    
    
    return
}

func NewExportAssetAppListResponse() (response *ExportAssetAppListResponse) {
    response = &ExportAssetAppListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetAppList
// This API is used to export the list of asset management applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetAppList(request *ExportAssetAppListRequest) (response *ExportAssetAppListResponse, err error) {
    return c.ExportAssetAppListWithContext(context.Background(), request)
}

// ExportAssetAppList
// This API is used to export the list of asset management applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetAppListWithContext(ctx context.Context, request *ExportAssetAppListRequest) (response *ExportAssetAppListResponse, err error) {
    if request == nil {
        request = NewExportAssetAppListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetAppList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetAppList require credential")
    }

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

func NewExportAssetCoreModuleListRequest() (request *ExportAssetCoreModuleListRequest) {
    request = &ExportAssetCoreModuleListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetCoreModuleList")
    
    
    return
}

func NewExportAssetCoreModuleListResponse() (response *ExportAssetCoreModuleListResponse) {
    response = &ExportAssetCoreModuleListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetCoreModuleList
// This API is used to export the list of asset management kernel modules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetCoreModuleList(request *ExportAssetCoreModuleListRequest) (response *ExportAssetCoreModuleListResponse, err error) {
    return c.ExportAssetCoreModuleListWithContext(context.Background(), request)
}

// ExportAssetCoreModuleList
// This API is used to export the list of asset management kernel modules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetCoreModuleListWithContext(ctx context.Context, request *ExportAssetCoreModuleListRequest) (response *ExportAssetCoreModuleListResponse, err error) {
    if request == nil {
        request = NewExportAssetCoreModuleListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetCoreModuleList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetCoreModuleList require credential")
    }

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

func NewExportAssetDatabaseListRequest() (request *ExportAssetDatabaseListRequest) {
    request = &ExportAssetDatabaseListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetDatabaseList")
    
    
    return
}

func NewExportAssetDatabaseListResponse() (response *ExportAssetDatabaseListResponse) {
    response = &ExportAssetDatabaseListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetDatabaseList
// This API is used to export the list of asset management databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetDatabaseList(request *ExportAssetDatabaseListRequest) (response *ExportAssetDatabaseListResponse, err error) {
    return c.ExportAssetDatabaseListWithContext(context.Background(), request)
}

// ExportAssetDatabaseList
// This API is used to export the list of asset management databases.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetDatabaseListWithContext(ctx context.Context, request *ExportAssetDatabaseListRequest) (response *ExportAssetDatabaseListResponse, err error) {
    if request == nil {
        request = NewExportAssetDatabaseListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetDatabaseList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetDatabaseList require credential")
    }

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

func NewExportAssetEnvListRequest() (request *ExportAssetEnvListRequest) {
    request = &ExportAssetEnvListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetEnvList")
    
    
    return
}

func NewExportAssetEnvListResponse() (response *ExportAssetEnvListResponse) {
    response = &ExportAssetEnvListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetEnvList
// This API is used to export the list of asset management environment variables.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetEnvList(request *ExportAssetEnvListRequest) (response *ExportAssetEnvListResponse, err error) {
    return c.ExportAssetEnvListWithContext(context.Background(), request)
}

// ExportAssetEnvList
// This API is used to export the list of asset management environment variables.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetEnvListWithContext(ctx context.Context, request *ExportAssetEnvListRequest) (response *ExportAssetEnvListResponse, err error) {
    if request == nil {
        request = NewExportAssetEnvListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetEnvList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetEnvList require credential")
    }

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

func NewExportAssetInitServiceListRequest() (request *ExportAssetInitServiceListRequest) {
    request = &ExportAssetInitServiceListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetInitServiceList")
    
    
    return
}

func NewExportAssetInitServiceListResponse() (response *ExportAssetInitServiceListResponse) {
    response = &ExportAssetInitServiceListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetInitServiceList
// This API is used to export the list of asset management startup services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetInitServiceList(request *ExportAssetInitServiceListRequest) (response *ExportAssetInitServiceListResponse, err error) {
    return c.ExportAssetInitServiceListWithContext(context.Background(), request)
}

// ExportAssetInitServiceList
// This API is used to export the list of asset management startup services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetInitServiceListWithContext(ctx context.Context, request *ExportAssetInitServiceListRequest) (response *ExportAssetInitServiceListResponse, err error) {
    if request == nil {
        request = NewExportAssetInitServiceListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetInitServiceList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetInitServiceList require credential")
    }

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

func NewExportAssetJarListRequest() (request *ExportAssetJarListRequest) {
    request = &ExportAssetJarListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetJarList")
    
    
    return
}

func NewExportAssetJarListResponse() (response *ExportAssetJarListResponse) {
    response = &ExportAssetJarListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetJarList
// This API is used to export the list of Jar packages.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetJarList(request *ExportAssetJarListRequest) (response *ExportAssetJarListResponse, err error) {
    return c.ExportAssetJarListWithContext(context.Background(), request)
}

// ExportAssetJarList
// This API is used to export the list of Jar packages.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetJarListWithContext(ctx context.Context, request *ExportAssetJarListRequest) (response *ExportAssetJarListResponse, err error) {
    if request == nil {
        request = NewExportAssetJarListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetJarList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetJarList require credential")
    }

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

func NewExportAssetMachineDetailRequest() (request *ExportAssetMachineDetailRequest) {
    request = &ExportAssetMachineDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetMachineDetail")
    
    
    return
}

func NewExportAssetMachineDetailResponse() (response *ExportAssetMachineDetailResponse) {
    response = &ExportAssetMachineDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetMachineDetail
// This API is used to export asset management host resource details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetMachineDetail(request *ExportAssetMachineDetailRequest) (response *ExportAssetMachineDetailResponse, err error) {
    return c.ExportAssetMachineDetailWithContext(context.Background(), request)
}

// ExportAssetMachineDetail
// This API is used to export asset management host resource details.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetMachineDetailWithContext(ctx context.Context, request *ExportAssetMachineDetailRequest) (response *ExportAssetMachineDetailResponse, err error) {
    if request == nil {
        request = NewExportAssetMachineDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetMachineDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetMachineDetail require credential")
    }

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

func NewExportAssetMachineListRequest() (request *ExportAssetMachineListRequest) {
    request = &ExportAssetMachineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetMachineList")
    
    
    return
}

func NewExportAssetMachineListResponse() (response *ExportAssetMachineListResponse) {
    response = &ExportAssetMachineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetMachineList
// This API is used to export the list of resource monitoring.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetMachineList(request *ExportAssetMachineListRequest) (response *ExportAssetMachineListResponse, err error) {
    return c.ExportAssetMachineListWithContext(context.Background(), request)
}

// ExportAssetMachineList
// This API is used to export the list of resource monitoring.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetMachineListWithContext(ctx context.Context, request *ExportAssetMachineListRequest) (response *ExportAssetMachineListResponse, err error) {
    if request == nil {
        request = NewExportAssetMachineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetMachineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetMachineList require credential")
    }

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

func NewExportAssetPlanTaskListRequest() (request *ExportAssetPlanTaskListRequest) {
    request = &ExportAssetPlanTaskListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetPlanTaskList")
    
    
    return
}

func NewExportAssetPlanTaskListResponse() (response *ExportAssetPlanTaskListResponse) {
    response = &ExportAssetPlanTaskListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetPlanTaskList
// This API is used to export the list of scheduled asset management tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetPlanTaskList(request *ExportAssetPlanTaskListRequest) (response *ExportAssetPlanTaskListResponse, err error) {
    return c.ExportAssetPlanTaskListWithContext(context.Background(), request)
}

// ExportAssetPlanTaskList
// This API is used to export the list of scheduled asset management tasks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetPlanTaskListWithContext(ctx context.Context, request *ExportAssetPlanTaskListRequest) (response *ExportAssetPlanTaskListResponse, err error) {
    if request == nil {
        request = NewExportAssetPlanTaskListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetPlanTaskList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetPlanTaskList require credential")
    }

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

func NewExportAssetPortInfoListRequest() (request *ExportAssetPortInfoListRequest) {
    request = &ExportAssetPortInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetPortInfoList")
    
    
    return
}

func NewExportAssetPortInfoListResponse() (response *ExportAssetPortInfoListResponse) {
    response = &ExportAssetPortInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetPortInfoList
// This API is used to export the list of asset management ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetPortInfoList(request *ExportAssetPortInfoListRequest) (response *ExportAssetPortInfoListResponse, err error) {
    return c.ExportAssetPortInfoListWithContext(context.Background(), request)
}

// ExportAssetPortInfoList
// This API is used to export the list of asset management ports.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetPortInfoListWithContext(ctx context.Context, request *ExportAssetPortInfoListRequest) (response *ExportAssetPortInfoListResponse, err error) {
    if request == nil {
        request = NewExportAssetPortInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetPortInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetPortInfoList require credential")
    }

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

func NewExportAssetProcessInfoListRequest() (request *ExportAssetProcessInfoListRequest) {
    request = &ExportAssetProcessInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetProcessInfoList")
    
    
    return
}

func NewExportAssetProcessInfoListResponse() (response *ExportAssetProcessInfoListResponse) {
    response = &ExportAssetProcessInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetProcessInfoList
// This API is used to export the asset management process list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetProcessInfoList(request *ExportAssetProcessInfoListRequest) (response *ExportAssetProcessInfoListResponse, err error) {
    return c.ExportAssetProcessInfoListWithContext(context.Background(), request)
}

// ExportAssetProcessInfoList
// This API is used to export the asset management process list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetProcessInfoListWithContext(ctx context.Context, request *ExportAssetProcessInfoListRequest) (response *ExportAssetProcessInfoListResponse, err error) {
    if request == nil {
        request = NewExportAssetProcessInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetProcessInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetProcessInfoList require credential")
    }

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

func NewExportAssetRecentMachineInfoRequest() (request *ExportAssetRecentMachineInfoRequest) {
    request = &ExportAssetRecentMachineInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetRecentMachineInfo")
    
    
    return
}

func NewExportAssetRecentMachineInfoResponse() (response *ExportAssetRecentMachineInfoResponse) {
    response = &ExportAssetRecentMachineInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetRecentMachineInfo
// This API is used to export host trends of recent days (up to last 90 days).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetRecentMachineInfo(request *ExportAssetRecentMachineInfoRequest) (response *ExportAssetRecentMachineInfoResponse, err error) {
    return c.ExportAssetRecentMachineInfoWithContext(context.Background(), request)
}

// ExportAssetRecentMachineInfo
// This API is used to export host trends of recent days (up to last 90 days).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetRecentMachineInfoWithContext(ctx context.Context, request *ExportAssetRecentMachineInfoRequest) (response *ExportAssetRecentMachineInfoResponse, err error) {
    if request == nil {
        request = NewExportAssetRecentMachineInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetRecentMachineInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetRecentMachineInfo require credential")
    }

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

func NewExportAssetSystemPackageListRequest() (request *ExportAssetSystemPackageListRequest) {
    request = &ExportAssetSystemPackageListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetSystemPackageList")
    
    
    return
}

func NewExportAssetSystemPackageListResponse() (response *ExportAssetSystemPackageListResponse) {
    response = &ExportAssetSystemPackageListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetSystemPackageList
// This API is used to export the list of system installation packages for asset management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetSystemPackageList(request *ExportAssetSystemPackageListRequest) (response *ExportAssetSystemPackageListResponse, err error) {
    return c.ExportAssetSystemPackageListWithContext(context.Background(), request)
}

// ExportAssetSystemPackageList
// This API is used to export the list of system installation packages for asset management.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetSystemPackageListWithContext(ctx context.Context, request *ExportAssetSystemPackageListRequest) (response *ExportAssetSystemPackageListResponse, err error) {
    if request == nil {
        request = NewExportAssetSystemPackageListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetSystemPackageList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetSystemPackageList require credential")
    }

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

func NewExportAssetUserListRequest() (request *ExportAssetUserListRequest) {
    request = &ExportAssetUserListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetUserList")
    
    
    return
}

func NewExportAssetUserListResponse() (response *ExportAssetUserListResponse) {
    response = &ExportAssetUserListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetUserList
// This API is used to export the account list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
func (c *Client) ExportAssetUserList(request *ExportAssetUserListRequest) (response *ExportAssetUserListResponse, err error) {
    return c.ExportAssetUserListWithContext(context.Background(), request)
}

// ExportAssetUserList
// This API is used to export the account list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
func (c *Client) ExportAssetUserListWithContext(ctx context.Context, request *ExportAssetUserListRequest) (response *ExportAssetUserListResponse, err error) {
    if request == nil {
        request = NewExportAssetUserListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetUserList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetUserList require credential")
    }

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

func NewExportAssetWebAppListRequest() (request *ExportAssetWebAppListRequest) {
    request = &ExportAssetWebAppListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetWebAppList")
    
    
    return
}

func NewExportAssetWebAppListResponse() (response *ExportAssetWebAppListResponse) {
    response = &ExportAssetWebAppListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetWebAppList
// This API is used to export the list of asset management Web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebAppList(request *ExportAssetWebAppListRequest) (response *ExportAssetWebAppListResponse, err error) {
    return c.ExportAssetWebAppListWithContext(context.Background(), request)
}

// ExportAssetWebAppList
// This API is used to export the list of asset management Web applications.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebAppListWithContext(ctx context.Context, request *ExportAssetWebAppListRequest) (response *ExportAssetWebAppListResponse, err error) {
    if request == nil {
        request = NewExportAssetWebAppListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetWebAppList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetWebAppList require credential")
    }

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

func NewExportAssetWebFrameListRequest() (request *ExportAssetWebFrameListRequest) {
    request = &ExportAssetWebFrameListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetWebFrameList")
    
    
    return
}

func NewExportAssetWebFrameListResponse() (response *ExportAssetWebFrameListResponse) {
    response = &ExportAssetWebFrameListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetWebFrameList
// This API is used to export the list of asset management Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebFrameList(request *ExportAssetWebFrameListRequest) (response *ExportAssetWebFrameListResponse, err error) {
    return c.ExportAssetWebFrameListWithContext(context.Background(), request)
}

// ExportAssetWebFrameList
// This API is used to export the list of asset management Web frameworks.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebFrameListWithContext(ctx context.Context, request *ExportAssetWebFrameListRequest) (response *ExportAssetWebFrameListResponse, err error) {
    if request == nil {
        request = NewExportAssetWebFrameListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetWebFrameList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetWebFrameList require credential")
    }

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

func NewExportAssetWebLocationListRequest() (request *ExportAssetWebLocationListRequest) {
    request = &ExportAssetWebLocationListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetWebLocationList")
    
    
    return
}

func NewExportAssetWebLocationListResponse() (response *ExportAssetWebLocationListResponse) {
    response = &ExportAssetWebLocationListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetWebLocationList
// This API is used to export the list of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebLocationList(request *ExportAssetWebLocationListRequest) (response *ExportAssetWebLocationListResponse, err error) {
    return c.ExportAssetWebLocationListWithContext(context.Background(), request)
}

// ExportAssetWebLocationList
// This API is used to export the list of Web sites.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportAssetWebLocationListWithContext(ctx context.Context, request *ExportAssetWebLocationListRequest) (response *ExportAssetWebLocationListResponse, err error) {
    if request == nil {
        request = NewExportAssetWebLocationListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetWebLocationList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetWebLocationList require credential")
    }

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

func NewExportAssetWebServiceInfoListRequest() (request *ExportAssetWebServiceInfoListRequest) {
    request = &ExportAssetWebServiceInfoListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAssetWebServiceInfoList")
    
    
    return
}

func NewExportAssetWebServiceInfoListResponse() (response *ExportAssetWebServiceInfoListResponse) {
    response = &ExportAssetWebServiceInfoListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAssetWebServiceInfoList
// This API is used to export the list of asset management Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetWebServiceInfoList(request *ExportAssetWebServiceInfoListRequest) (response *ExportAssetWebServiceInfoListResponse, err error) {
    return c.ExportAssetWebServiceInfoListWithContext(context.Background(), request)
}

// ExportAssetWebServiceInfoList
// This API is used to export the list of asset management Web services.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAssetWebServiceInfoListWithContext(ctx context.Context, request *ExportAssetWebServiceInfoListRequest) (response *ExportAssetWebServiceInfoListResponse, err error) {
    if request == nil {
        request = NewExportAssetWebServiceInfoListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAssetWebServiceInfoList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAssetWebServiceInfoList require credential")
    }

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

func NewExportAttackEventsRequest() (request *ExportAttackEventsRequest) {
    request = &ExportAttackEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportAttackEvents")
    
    
    return
}

func NewExportAttackEventsResponse() (response *ExportAttackEventsResponse) {
    response = &ExportAttackEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportAttackEvents
// This API is used to export network attack events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAttackEvents(request *ExportAttackEventsRequest) (response *ExportAttackEventsResponse, err error) {
    return c.ExportAttackEventsWithContext(context.Background(), request)
}

// ExportAttackEvents
// This API is used to export network attack events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportAttackEventsWithContext(ctx context.Context, request *ExportAttackEventsRequest) (response *ExportAttackEventsResponse, err error) {
    if request == nil {
        request = NewExportAttackEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportAttackEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportAttackEvents require credential")
    }

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

func NewExportBaselineEffectHostListRequest() (request *ExportBaselineEffectHostListRequest) {
    request = &ExportBaselineEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBaselineEffectHostList")
    
    
    return
}

func NewExportBaselineEffectHostListResponse() (response *ExportBaselineEffectHostListResponse) {
    response = &ExportBaselineEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBaselineEffectHostList
// This API is used to export the list of hosts affected by baseline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportBaselineEffectHostList(request *ExportBaselineEffectHostListRequest) (response *ExportBaselineEffectHostListResponse, err error) {
    return c.ExportBaselineEffectHostListWithContext(context.Background(), request)
}

// ExportBaselineEffectHostList
// This API is used to export the list of hosts affected by baseline.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportBaselineEffectHostListWithContext(ctx context.Context, request *ExportBaselineEffectHostListRequest) (response *ExportBaselineEffectHostListResponse, err error) {
    if request == nil {
        request = NewExportBaselineEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBaselineEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBaselineEffectHostList require credential")
    }

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

func NewExportBaselineFixListRequest() (request *ExportBaselineFixListRequest) {
    request = &ExportBaselineFixListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBaselineFixList")
    
    
    return
}

func NewExportBaselineFixListResponse() (response *ExportBaselineFixListResponse) {
    response = &ExportBaselineFixListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBaselineFixList
// This API is used to export the list of fixing baselines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineFixList(request *ExportBaselineFixListRequest) (response *ExportBaselineFixListResponse, err error) {
    return c.ExportBaselineFixListWithContext(context.Background(), request)
}

// ExportBaselineFixList
// This API is used to export the list of fixing baselines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineFixListWithContext(ctx context.Context, request *ExportBaselineFixListRequest) (response *ExportBaselineFixListResponse, err error) {
    if request == nil {
        request = NewExportBaselineFixListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBaselineFixList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBaselineFixList require credential")
    }

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

func NewExportBaselineHostDetectListRequest() (request *ExportBaselineHostDetectListRequest) {
    request = &ExportBaselineHostDetectListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBaselineHostDetectList")
    
    
    return
}

func NewExportBaselineHostDetectListResponse() (response *ExportBaselineHostDetectListResponse) {
    response = &ExportBaselineHostDetectListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBaselineHostDetectList
// This API is used to export the baseline for host detection.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineHostDetectList(request *ExportBaselineHostDetectListRequest) (response *ExportBaselineHostDetectListResponse, err error) {
    return c.ExportBaselineHostDetectListWithContext(context.Background(), request)
}

// ExportBaselineHostDetectList
// This API is used to export the baseline for host detection.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineHostDetectListWithContext(ctx context.Context, request *ExportBaselineHostDetectListRequest) (response *ExportBaselineHostDetectListResponse, err error) {
    if request == nil {
        request = NewExportBaselineHostDetectListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBaselineHostDetectList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBaselineHostDetectList require credential")
    }

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

func NewExportBaselineItemDetectListRequest() (request *ExportBaselineItemDetectListRequest) {
    request = &ExportBaselineItemDetectListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBaselineItemDetectList")
    
    
    return
}

func NewExportBaselineItemDetectListResponse() (response *ExportBaselineItemDetectListResponse) {
    response = &ExportBaselineItemDetectListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBaselineItemDetectList
// This API is used to export baseline check items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineItemDetectList(request *ExportBaselineItemDetectListRequest) (response *ExportBaselineItemDetectListResponse, err error) {
    return c.ExportBaselineItemDetectListWithContext(context.Background(), request)
}

// ExportBaselineItemDetectList
// This API is used to export baseline check items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportBaselineItemDetectListWithContext(ctx context.Context, request *ExportBaselineItemDetectListRequest) (response *ExportBaselineItemDetectListResponse, err error) {
    if request == nil {
        request = NewExportBaselineItemDetectListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBaselineItemDetectList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBaselineItemDetectList require credential")
    }

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

func NewExportBaselineListRequest() (request *ExportBaselineListRequest) {
    request = &ExportBaselineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBaselineList")
    
    
    return
}

func NewExportBaselineListResponse() (response *ExportBaselineListResponse) {
    response = &ExportBaselineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBaselineList
// This API is used to export the list of baselines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportBaselineList(request *ExportBaselineListRequest) (response *ExportBaselineListResponse, err error) {
    return c.ExportBaselineListWithContext(context.Background(), request)
}

// ExportBaselineList
// This API is used to export the list of baselines.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportBaselineListWithContext(ctx context.Context, request *ExportBaselineListRequest) (response *ExportBaselineListResponse, err error) {
    if request == nil {
        request = NewExportBaselineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBaselineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBaselineList require credential")
    }

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

func NewExportBashEventsRequest() (request *ExportBashEventsRequest) {
    request = &ExportBashEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBashEvents")
    
    
    return
}

func NewExportBashEventsResponse() (response *ExportBashEventsResponse) {
    response = &ExportBashEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBashEvents
// This API is used to export high-risk command events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashEvents(request *ExportBashEventsRequest) (response *ExportBashEventsResponse, err error) {
    return c.ExportBashEventsWithContext(context.Background(), request)
}

// ExportBashEvents
// This API is used to export high-risk command events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashEventsWithContext(ctx context.Context, request *ExportBashEventsRequest) (response *ExportBashEventsResponse, err error) {
    if request == nil {
        request = NewExportBashEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBashEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBashEvents require credential")
    }

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

func NewExportBashEventsNewRequest() (request *ExportBashEventsNewRequest) {
    request = &ExportBashEventsNewRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBashEventsNew")
    
    
    return
}

func NewExportBashEventsNewResponse() (response *ExportBashEventsNewResponse) {
    response = &ExportBashEventsNewResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBashEventsNew
// This API is used to export high-risk command events (new).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashEventsNew(request *ExportBashEventsNewRequest) (response *ExportBashEventsNewResponse, err error) {
    return c.ExportBashEventsNewWithContext(context.Background(), request)
}

// ExportBashEventsNew
// This API is used to export high-risk command events (new).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashEventsNewWithContext(ctx context.Context, request *ExportBashEventsNewRequest) (response *ExportBashEventsNewResponse, err error) {
    if request == nil {
        request = NewExportBashEventsNewRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBashEventsNew")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBashEventsNew require credential")
    }

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

func NewExportBashPoliciesRequest() (request *ExportBashPoliciesRequest) {
    request = &ExportBashPoliciesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBashPolicies")
    
    
    return
}

func NewExportBashPoliciesResponse() (response *ExportBashPoliciesResponse) {
    response = &ExportBashPoliciesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBashPolicies
// This API is used to export the high-risk command policy.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashPolicies(request *ExportBashPoliciesRequest) (response *ExportBashPoliciesResponse, err error) {
    return c.ExportBashPoliciesWithContext(context.Background(), request)
}

// ExportBashPolicies
// This API is used to export the high-risk command policy.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBashPoliciesWithContext(ctx context.Context, request *ExportBashPoliciesRequest) (response *ExportBashPoliciesResponse, err error) {
    if request == nil {
        request = NewExportBashPoliciesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBashPolicies")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBashPolicies require credential")
    }

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

func NewExportBruteAttacksRequest() (request *ExportBruteAttacksRequest) {
    request = &ExportBruteAttacksRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportBruteAttacks")
    
    
    return
}

func NewExportBruteAttacksResponse() (response *ExportBruteAttacksResponse) {
    response = &ExportBruteAttacksResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportBruteAttacks
// This API is used to export password cracking records to a CSV file.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBruteAttacks(request *ExportBruteAttacksRequest) (response *ExportBruteAttacksResponse, err error) {
    return c.ExportBruteAttacksWithContext(context.Background(), request)
}

// ExportBruteAttacks
// This API is used to export password cracking records to a CSV file.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportBruteAttacksWithContext(ctx context.Context, request *ExportBruteAttacksRequest) (response *ExportBruteAttacksResponse, err error) {
    if request == nil {
        request = NewExportBruteAttacksRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportBruteAttacks")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportBruteAttacks require credential")
    }

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

func NewExportFileTamperEventsRequest() (request *ExportFileTamperEventsRequest) {
    request = &ExportFileTamperEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportFileTamperEvents")
    
    
    return
}

func NewExportFileTamperEventsResponse() (response *ExportFileTamperEventsResponse) {
    response = &ExportFileTamperEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportFileTamperEvents
// This API is used to export core file events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportFileTamperEvents(request *ExportFileTamperEventsRequest) (response *ExportFileTamperEventsResponse, err error) {
    return c.ExportFileTamperEventsWithContext(context.Background(), request)
}

// ExportFileTamperEvents
// This API is used to export core file events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportFileTamperEventsWithContext(ctx context.Context, request *ExportFileTamperEventsRequest) (response *ExportFileTamperEventsResponse, err error) {
    if request == nil {
        request = NewExportFileTamperEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportFileTamperEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportFileTamperEvents require credential")
    }

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

func NewExportFileTamperRulesRequest() (request *ExportFileTamperRulesRequest) {
    request = &ExportFileTamperRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportFileTamperRules")
    
    
    return
}

func NewExportFileTamperRulesResponse() (response *ExportFileTamperRulesResponse) {
    response = &ExportFileTamperRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportFileTamperRules
// This API is used to export core file monitoring rules.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportFileTamperRules(request *ExportFileTamperRulesRequest) (response *ExportFileTamperRulesResponse, err error) {
    return c.ExportFileTamperRulesWithContext(context.Background(), request)
}

// ExportFileTamperRules
// This API is used to export core file monitoring rules.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportFileTamperRulesWithContext(ctx context.Context, request *ExportFileTamperRulesRequest) (response *ExportFileTamperRulesResponse, err error) {
    if request == nil {
        request = NewExportFileTamperRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportFileTamperRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportFileTamperRules require credential")
    }

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

func NewExportIgnoreBaselineRuleRequest() (request *ExportIgnoreBaselineRuleRequest) {
    request = &ExportIgnoreBaselineRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportIgnoreBaselineRule")
    
    
    return
}

func NewExportIgnoreBaselineRuleResponse() (response *ExportIgnoreBaselineRuleResponse) {
    response = &ExportIgnoreBaselineRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportIgnoreBaselineRule
// This API is used to export information of ignored baseline detection items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportIgnoreBaselineRule(request *ExportIgnoreBaselineRuleRequest) (response *ExportIgnoreBaselineRuleResponse, err error) {
    return c.ExportIgnoreBaselineRuleWithContext(context.Background(), request)
}

// ExportIgnoreBaselineRule
// This API is used to export information of ignored baseline detection items.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportIgnoreBaselineRuleWithContext(ctx context.Context, request *ExportIgnoreBaselineRuleRequest) (response *ExportIgnoreBaselineRuleResponse, err error) {
    if request == nil {
        request = NewExportIgnoreBaselineRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportIgnoreBaselineRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportIgnoreBaselineRule require credential")
    }

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

func NewExportIgnoreRuleEffectHostListRequest() (request *ExportIgnoreRuleEffectHostListRequest) {
    request = &ExportIgnoreRuleEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportIgnoreRuleEffectHostList")
    
    
    return
}

func NewExportIgnoreRuleEffectHostListResponse() (response *ExportIgnoreRuleEffectHostListResponse) {
    response = &ExportIgnoreRuleEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportIgnoreRuleEffectHostList
// This API is used to export the list of hosts affected by ignored detection items based on detection item IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportIgnoreRuleEffectHostList(request *ExportIgnoreRuleEffectHostListRequest) (response *ExportIgnoreRuleEffectHostListResponse, err error) {
    return c.ExportIgnoreRuleEffectHostListWithContext(context.Background(), request)
}

// ExportIgnoreRuleEffectHostList
// This API is used to export the list of hosts affected by ignored detection items based on detection item IDs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportIgnoreRuleEffectHostListWithContext(ctx context.Context, request *ExportIgnoreRuleEffectHostListRequest) (response *ExportIgnoreRuleEffectHostListResponse, err error) {
    if request == nil {
        request = NewExportIgnoreRuleEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportIgnoreRuleEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportIgnoreRuleEffectHostList require credential")
    }

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

func NewExportJavaMemShellPluginsRequest() (request *ExportJavaMemShellPluginsRequest) {
    request = &ExportJavaMemShellPluginsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportJavaMemShellPlugins")
    
    
    return
}

func NewExportJavaMemShellPluginsResponse() (response *ExportJavaMemShellPluginsResponse) {
    response = &ExportJavaMemShellPluginsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportJavaMemShellPlugins
// This API is used to export the Java webshell plugin information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportJavaMemShellPlugins(request *ExportJavaMemShellPluginsRequest) (response *ExportJavaMemShellPluginsResponse, err error) {
    return c.ExportJavaMemShellPluginsWithContext(context.Background(), request)
}

// ExportJavaMemShellPlugins
// This API is used to export the Java webshell plugin information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportJavaMemShellPluginsWithContext(ctx context.Context, request *ExportJavaMemShellPluginsRequest) (response *ExportJavaMemShellPluginsResponse, err error) {
    if request == nil {
        request = NewExportJavaMemShellPluginsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportJavaMemShellPlugins")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportJavaMemShellPlugins require credential")
    }

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

func NewExportJavaMemShellsRequest() (request *ExportJavaMemShellsRequest) {
    request = &ExportJavaMemShellsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportJavaMemShells")
    
    
    return
}

func NewExportJavaMemShellsResponse() (response *ExportJavaMemShellsResponse) {
    response = &ExportJavaMemShellsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportJavaMemShells
// This API is used to export the list of Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportJavaMemShells(request *ExportJavaMemShellsRequest) (response *ExportJavaMemShellsResponse, err error) {
    return c.ExportJavaMemShellsWithContext(context.Background(), request)
}

// ExportJavaMemShells
// This API is used to export the list of Java webshell events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportJavaMemShellsWithContext(ctx context.Context, request *ExportJavaMemShellsRequest) (response *ExportJavaMemShellsResponse, err error) {
    if request == nil {
        request = NewExportJavaMemShellsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportJavaMemShells")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportJavaMemShells require credential")
    }

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

func NewExportLicenseDetailRequest() (request *ExportLicenseDetailRequest) {
    request = &ExportLicenseDetailRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportLicenseDetail")
    
    
    return
}

func NewExportLicenseDetailResponse() (response *ExportLicenseDetailResponse) {
    response = &ExportLicenseDetailResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportLicenseDetail
// This API is used to export authorization details.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportLicenseDetail(request *ExportLicenseDetailRequest) (response *ExportLicenseDetailResponse, err error) {
    return c.ExportLicenseDetailWithContext(context.Background(), request)
}

// ExportLicenseDetail
// This API is used to export authorization details.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportLicenseDetailWithContext(ctx context.Context, request *ExportLicenseDetailRequest) (response *ExportLicenseDetailResponse, err error) {
    if request == nil {
        request = NewExportLicenseDetailRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportLicenseDetail")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportLicenseDetail require credential")
    }

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

func NewExportMaliciousRequestsRequest() (request *ExportMaliciousRequestsRequest) {
    request = &ExportMaliciousRequestsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportMaliciousRequests")
    
    
    return
}

func NewExportMaliciousRequestsResponse() (response *ExportMaliciousRequestsResponse) {
    response = &ExportMaliciousRequestsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportMaliciousRequests
// This API is used to export the downloaded malicious request files.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportMaliciousRequests(request *ExportMaliciousRequestsRequest) (response *ExportMaliciousRequestsResponse, err error) {
    return c.ExportMaliciousRequestsWithContext(context.Background(), request)
}

// ExportMaliciousRequests
// This API is used to export the downloaded malicious request files.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportMaliciousRequestsWithContext(ctx context.Context, request *ExportMaliciousRequestsRequest) (response *ExportMaliciousRequestsResponse, err error) {
    if request == nil {
        request = NewExportMaliciousRequestsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportMaliciousRequests")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportMaliciousRequests require credential")
    }

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

func NewExportMalwaresRequest() (request *ExportMalwaresRequest) {
    request = &ExportMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportMalwares")
    
    
    return
}

func NewExportMalwaresResponse() (response *ExportMalwaresResponse) {
    response = &ExportMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportMalwares
// This API is used to export Trojan records to a CSV file.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportMalwares(request *ExportMalwaresRequest) (response *ExportMalwaresResponse, err error) {
    return c.ExportMalwaresWithContext(context.Background(), request)
}

// ExportMalwares
// This API is used to export Trojan records to a CSV file.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportMalwaresWithContext(ctx context.Context, request *ExportMalwaresRequest) (response *ExportMalwaresResponse, err error) {
    if request == nil {
        request = NewExportMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportMalwares require credential")
    }

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

func NewExportNonlocalLoginPlacesRequest() (request *ExportNonlocalLoginPlacesRequest) {
    request = &ExportNonlocalLoginPlacesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportNonlocalLoginPlaces")
    
    
    return
}

func NewExportNonlocalLoginPlacesResponse() (response *ExportNonlocalLoginPlacesResponse) {
    response = &ExportNonlocalLoginPlacesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportNonlocalLoginPlaces
// This API is used to export cross-region log-in event records in CSV format.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportNonlocalLoginPlaces(request *ExportNonlocalLoginPlacesRequest) (response *ExportNonlocalLoginPlacesResponse, err error) {
    return c.ExportNonlocalLoginPlacesWithContext(context.Background(), request)
}

// ExportNonlocalLoginPlaces
// This API is used to export cross-region log-in event records in CSV format.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportNonlocalLoginPlacesWithContext(ctx context.Context, request *ExportNonlocalLoginPlacesRequest) (response *ExportNonlocalLoginPlacesResponse, err error) {
    if request == nil {
        request = NewExportNonlocalLoginPlacesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportNonlocalLoginPlaces")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportNonlocalLoginPlaces require credential")
    }

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

func NewExportPrivilegeEventsRequest() (request *ExportPrivilegeEventsRequest) {
    request = &ExportPrivilegeEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportPrivilegeEvents")
    
    
    return
}

func NewExportPrivilegeEventsResponse() (response *ExportPrivilegeEventsResponse) {
    response = &ExportPrivilegeEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportPrivilegeEvents
// This API is used to export local privilege escalation events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportPrivilegeEvents(request *ExportPrivilegeEventsRequest) (response *ExportPrivilegeEventsResponse, err error) {
    return c.ExportPrivilegeEventsWithContext(context.Background(), request)
}

// ExportPrivilegeEvents
// This API is used to export local privilege escalation events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
func (c *Client) ExportPrivilegeEventsWithContext(ctx context.Context, request *ExportPrivilegeEventsRequest) (response *ExportPrivilegeEventsResponse, err error) {
    if request == nil {
        request = NewExportPrivilegeEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportPrivilegeEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportPrivilegeEvents require credential")
    }

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

func NewExportRansomDefenseBackupListRequest() (request *ExportRansomDefenseBackupListRequest) {
    request = &ExportRansomDefenseBackupListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRansomDefenseBackupList")
    
    
    return
}

func NewExportRansomDefenseBackupListResponse() (response *ExportRansomDefenseBackupListResponse) {
    response = &ExportRansomDefenseBackupListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRansomDefenseBackupList
// This API is used to export the list of host snapshot backups.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseBackupList(request *ExportRansomDefenseBackupListRequest) (response *ExportRansomDefenseBackupListResponse, err error) {
    return c.ExportRansomDefenseBackupListWithContext(context.Background(), request)
}

// ExportRansomDefenseBackupList
// This API is used to export the list of host snapshot backups.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseBackupListWithContext(ctx context.Context, request *ExportRansomDefenseBackupListRequest) (response *ExportRansomDefenseBackupListResponse, err error) {
    if request == nil {
        request = NewExportRansomDefenseBackupListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRansomDefenseBackupList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRansomDefenseBackupList require credential")
    }

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

func NewExportRansomDefenseEventsListRequest() (request *ExportRansomDefenseEventsListRequest) {
    request = &ExportRansomDefenseEventsListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRansomDefenseEventsList")
    
    
    return
}

func NewExportRansomDefenseEventsListResponse() (response *ExportRansomDefenseEventsListResponse) {
    response = &ExportRansomDefenseEventsListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRansomDefenseEventsList
// This API is used to export the list of anti-ransomware events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseEventsList(request *ExportRansomDefenseEventsListRequest) (response *ExportRansomDefenseEventsListResponse, err error) {
    return c.ExportRansomDefenseEventsListWithContext(context.Background(), request)
}

// ExportRansomDefenseEventsList
// This API is used to export the list of anti-ransomware events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseEventsListWithContext(ctx context.Context, request *ExportRansomDefenseEventsListRequest) (response *ExportRansomDefenseEventsListResponse, err error) {
    if request == nil {
        request = NewExportRansomDefenseEventsListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRansomDefenseEventsList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRansomDefenseEventsList require credential")
    }

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

func NewExportRansomDefenseMachineListRequest() (request *ExportRansomDefenseMachineListRequest) {
    request = &ExportRansomDefenseMachineListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRansomDefenseMachineList")
    
    
    return
}

func NewExportRansomDefenseMachineListResponse() (response *ExportRansomDefenseMachineListResponse) {
    response = &ExportRansomDefenseMachineListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRansomDefenseMachineList
// This API is used to export the backup details list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseMachineList(request *ExportRansomDefenseMachineListRequest) (response *ExportRansomDefenseMachineListResponse, err error) {
    return c.ExportRansomDefenseMachineListWithContext(context.Background(), request)
}

// ExportRansomDefenseMachineList
// This API is used to export the backup details list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseMachineListWithContext(ctx context.Context, request *ExportRansomDefenseMachineListRequest) (response *ExportRansomDefenseMachineListResponse, err error) {
    if request == nil {
        request = NewExportRansomDefenseMachineListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRansomDefenseMachineList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRansomDefenseMachineList require credential")
    }

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

func NewExportRansomDefenseStrategyListRequest() (request *ExportRansomDefenseStrategyListRequest) {
    request = &ExportRansomDefenseStrategyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRansomDefenseStrategyList")
    
    
    return
}

func NewExportRansomDefenseStrategyListResponse() (response *ExportRansomDefenseStrategyListResponse) {
    response = &ExportRansomDefenseStrategyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRansomDefenseStrategyList
// This API is used to export the anti-ransomware policy list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseStrategyList(request *ExportRansomDefenseStrategyListRequest) (response *ExportRansomDefenseStrategyListResponse, err error) {
    return c.ExportRansomDefenseStrategyListWithContext(context.Background(), request)
}

// ExportRansomDefenseStrategyList
// This API is used to export the anti-ransomware policy list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseStrategyListWithContext(ctx context.Context, request *ExportRansomDefenseStrategyListRequest) (response *ExportRansomDefenseStrategyListResponse, err error) {
    if request == nil {
        request = NewExportRansomDefenseStrategyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRansomDefenseStrategyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRansomDefenseStrategyList require credential")
    }

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

func NewExportRansomDefenseStrategyMachinesRequest() (request *ExportRansomDefenseStrategyMachinesRequest) {
    request = &ExportRansomDefenseStrategyMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRansomDefenseStrategyMachines")
    
    
    return
}

func NewExportRansomDefenseStrategyMachinesResponse() (response *ExportRansomDefenseStrategyMachinesResponse) {
    response = &ExportRansomDefenseStrategyMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRansomDefenseStrategyMachines
// This API is used to export the list of machines bound to ransomware defense policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseStrategyMachines(request *ExportRansomDefenseStrategyMachinesRequest) (response *ExportRansomDefenseStrategyMachinesResponse, err error) {
    return c.ExportRansomDefenseStrategyMachinesWithContext(context.Background(), request)
}

// ExportRansomDefenseStrategyMachines
// This API is used to export the list of machines bound to ransomware defense policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportRansomDefenseStrategyMachinesWithContext(ctx context.Context, request *ExportRansomDefenseStrategyMachinesRequest) (response *ExportRansomDefenseStrategyMachinesResponse, err error) {
    if request == nil {
        request = NewExportRansomDefenseStrategyMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRansomDefenseStrategyMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRansomDefenseStrategyMachines require credential")
    }

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

func NewExportReverseShellEventsRequest() (request *ExportReverseShellEventsRequest) {
    request = &ExportReverseShellEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportReverseShellEvents")
    
    
    return
}

func NewExportReverseShellEventsResponse() (response *ExportReverseShellEventsResponse) {
    response = &ExportReverseShellEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportReverseShellEvents
// This API is used to export reverse shell events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportReverseShellEvents(request *ExportReverseShellEventsRequest) (response *ExportReverseShellEventsResponse, err error) {
    return c.ExportReverseShellEventsWithContext(context.Background(), request)
}

// ExportReverseShellEvents
// This API is used to export reverse shell events.
//
// error code that may be returned:
//  FAILEDOPERATION_EXPORT = "FailedOperation.Export"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportReverseShellEventsWithContext(ctx context.Context, request *ExportReverseShellEventsRequest) (response *ExportReverseShellEventsResponse, err error) {
    if request == nil {
        request = NewExportReverseShellEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportReverseShellEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportReverseShellEvents require credential")
    }

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

func NewExportRiskDnsEventListRequest() (request *ExportRiskDnsEventListRequest) {
    request = &ExportRiskDnsEventListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRiskDnsEventList")
    
    
    return
}

func NewExportRiskDnsEventListResponse() (response *ExportRiskDnsEventListResponse) {
    response = &ExportRiskDnsEventListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRiskDnsEventList
// This API is used to export the malicious request event list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportRiskDnsEventList(request *ExportRiskDnsEventListRequest) (response *ExportRiskDnsEventListResponse, err error) {
    return c.ExportRiskDnsEventListWithContext(context.Background(), request)
}

// ExportRiskDnsEventList
// This API is used to export the malicious request event list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportRiskDnsEventListWithContext(ctx context.Context, request *ExportRiskDnsEventListRequest) (response *ExportRiskDnsEventListResponse, err error) {
    if request == nil {
        request = NewExportRiskDnsEventListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRiskDnsEventList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRiskDnsEventList require credential")
    }

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

func NewExportRiskDnsPolicyListRequest() (request *ExportRiskDnsPolicyListRequest) {
    request = &ExportRiskDnsPolicyListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRiskDnsPolicyList")
    
    
    return
}

func NewExportRiskDnsPolicyListResponse() (response *ExportRiskDnsPolicyListResponse) {
    response = &ExportRiskDnsPolicyListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRiskDnsPolicyList
// This API is used to export the malicious request policy list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ExportRiskDnsPolicyList(request *ExportRiskDnsPolicyListRequest) (response *ExportRiskDnsPolicyListResponse, err error) {
    return c.ExportRiskDnsPolicyListWithContext(context.Background(), request)
}

// ExportRiskDnsPolicyList
// This API is used to export the malicious request policy list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ExportRiskDnsPolicyListWithContext(ctx context.Context, request *ExportRiskDnsPolicyListRequest) (response *ExportRiskDnsPolicyListResponse, err error) {
    if request == nil {
        request = NewExportRiskDnsPolicyListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRiskDnsPolicyList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRiskDnsPolicyList require credential")
    }

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

func NewExportRiskProcessEventsRequest() (request *ExportRiskProcessEventsRequest) {
    request = &ExportRiskProcessEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportRiskProcessEvents")
    
    
    return
}

func NewExportRiskProcessEventsResponse() (response *ExportRiskProcessEventsResponse) {
    response = &ExportRiskProcessEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportRiskProcessEvents
// This API is used to export abnormal process events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportRiskProcessEvents(request *ExportRiskProcessEventsRequest) (response *ExportRiskProcessEventsResponse, err error) {
    return c.ExportRiskProcessEventsWithContext(context.Background(), request)
}

// ExportRiskProcessEvents
// This API is used to export abnormal process events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ExportRiskProcessEventsWithContext(ctx context.Context, request *ExportRiskProcessEventsRequest) (response *ExportRiskProcessEventsResponse, err error) {
    if request == nil {
        request = NewExportRiskProcessEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportRiskProcessEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportRiskProcessEvents require credential")
    }

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

func NewExportScanTaskDetailsRequest() (request *ExportScanTaskDetailsRequest) {
    request = &ExportScanTaskDetailsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportScanTaskDetails")
    
    
    return
}

func NewExportScanTaskDetailsResponse() (response *ExportScanTaskDetailsResponse) {
    response = &ExportScanTaskDetailsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportScanTaskDetails
// This API is used to export the specified scan task details by task ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportScanTaskDetails(request *ExportScanTaskDetailsRequest) (response *ExportScanTaskDetailsResponse, err error) {
    return c.ExportScanTaskDetailsWithContext(context.Background(), request)
}

// ExportScanTaskDetails
// This API is used to export the specified scan task details by task ID.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportScanTaskDetailsWithContext(ctx context.Context, request *ExportScanTaskDetailsRequest) (response *ExportScanTaskDetailsResponse, err error) {
    if request == nil {
        request = NewExportScanTaskDetailsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportScanTaskDetails")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportScanTaskDetails require credential")
    }

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

func NewExportSecurityTrendsRequest() (request *ExportSecurityTrendsRequest) {
    request = &ExportSecurityTrendsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportSecurityTrends")
    
    
    return
}

func NewExportSecurityTrendsResponse() (response *ExportSecurityTrendsResponse) {
    response = &ExportSecurityTrendsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportSecurityTrends
// This API is used to export risk trends.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ExportSecurityTrends(request *ExportSecurityTrendsRequest) (response *ExportSecurityTrendsResponse, err error) {
    return c.ExportSecurityTrendsWithContext(context.Background(), request)
}

// ExportSecurityTrends
// This API is used to export risk trends.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) ExportSecurityTrendsWithContext(ctx context.Context, request *ExportSecurityTrendsRequest) (response *ExportSecurityTrendsResponse, err error) {
    if request == nil {
        request = NewExportSecurityTrendsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportSecurityTrends")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportSecurityTrends require credential")
    }

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

func NewExportTasksRequest() (request *ExportTasksRequest) {
    request = &ExportTasksRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportTasks")
    
    
    return
}

func NewExportTasksResponse() (response *ExportTasksResponse) {
    response = &ExportTasksResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportTasks
// This API is used to export log files with large data volumes asynchronously.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportTasks(request *ExportTasksRequest) (response *ExportTasksResponse, err error) {
    return c.ExportTasksWithContext(context.Background(), request)
}

// ExportTasks
// This API is used to export log files with large data volumes asynchronously.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ExportTasksWithContext(ctx context.Context, request *ExportTasksRequest) (response *ExportTasksResponse, err error) {
    if request == nil {
        request = NewExportTasksRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportTasks")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportTasks require credential")
    }

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

func NewExportVulDefenceEventRequest() (request *ExportVulDefenceEventRequest) {
    request = &ExportVulDefenceEventRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulDefenceEvent")
    
    
    return
}

func NewExportVulDefenceEventResponse() (response *ExportVulDefenceEventResponse) {
    response = &ExportVulDefenceEventResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulDefenceEvent
// This API is used to export vulnerability defense events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefenceEvent(request *ExportVulDefenceEventRequest) (response *ExportVulDefenceEventResponse, err error) {
    return c.ExportVulDefenceEventWithContext(context.Background(), request)
}

// ExportVulDefenceEvent
// This API is used to export vulnerability defense events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefenceEventWithContext(ctx context.Context, request *ExportVulDefenceEventRequest) (response *ExportVulDefenceEventResponse, err error) {
    if request == nil {
        request = NewExportVulDefenceEventRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulDefenceEvent")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulDefenceEvent require credential")
    }

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

func NewExportVulDefenceListRequest() (request *ExportVulDefenceListRequest) {
    request = &ExportVulDefenceListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulDefenceList")
    
    
    return
}

func NewExportVulDefenceListResponse() (response *ExportVulDefenceListResponse) {
    response = &ExportVulDefenceListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulDefenceList
// This API is used to export the list of vulnerability defenses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefenceList(request *ExportVulDefenceListRequest) (response *ExportVulDefenceListResponse, err error) {
    return c.ExportVulDefenceListWithContext(context.Background(), request)
}

// ExportVulDefenceList
// This API is used to export the list of vulnerability defenses.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefenceListWithContext(ctx context.Context, request *ExportVulDefenceListRequest) (response *ExportVulDefenceListResponse, err error) {
    if request == nil {
        request = NewExportVulDefenceListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulDefenceList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulDefenceList require credential")
    }

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

func NewExportVulDefencePluginEventRequest() (request *ExportVulDefencePluginEventRequest) {
    request = &ExportVulDefencePluginEventRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulDefencePluginEvent")
    
    
    return
}

func NewExportVulDefencePluginEventResponse() (response *ExportVulDefencePluginEventResponse) {
    response = &ExportVulDefencePluginEventResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulDefencePluginEvent
// This API is used to export vulnerability defense plugin events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefencePluginEvent(request *ExportVulDefencePluginEventRequest) (response *ExportVulDefencePluginEventResponse, err error) {
    return c.ExportVulDefencePluginEventWithContext(context.Background(), request)
}

// ExportVulDefencePluginEvent
// This API is used to export vulnerability defense plugin events.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDefencePluginEventWithContext(ctx context.Context, request *ExportVulDefencePluginEventRequest) (response *ExportVulDefencePluginEventResponse, err error) {
    if request == nil {
        request = NewExportVulDefencePluginEventRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulDefencePluginEvent")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulDefencePluginEvent require credential")
    }

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

func NewExportVulDetectionExcelRequest() (request *ExportVulDetectionExcelRequest) {
    request = &ExportVulDetectionExcelRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulDetectionExcel")
    
    
    return
}

func NewExportVulDetectionExcelResponse() (response *ExportVulDetectionExcelResponse) {
    response = &ExportVulDetectionExcelResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulDetectionExcel
// This API is used to export the vulnerability detection Excel document.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDetectionExcel(request *ExportVulDetectionExcelRequest) (response *ExportVulDetectionExcelResponse, err error) {
    return c.ExportVulDetectionExcelWithContext(context.Background(), request)
}

// ExportVulDetectionExcel
// This API is used to export the vulnerability detection Excel document.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDetectionExcelWithContext(ctx context.Context, request *ExportVulDetectionExcelRequest) (response *ExportVulDetectionExcelResponse, err error) {
    if request == nil {
        request = NewExportVulDetectionExcelRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulDetectionExcel")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulDetectionExcel require credential")
    }

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

func NewExportVulDetectionReportRequest() (request *ExportVulDetectionReportRequest) {
    request = &ExportVulDetectionReportRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulDetectionReport")
    
    
    return
}

func NewExportVulDetectionReportResponse() (response *ExportVulDetectionReportResponse) {
    response = &ExportVulDetectionReportResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulDetectionReport
// This API is used to export the vulnerability detection report.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDetectionReport(request *ExportVulDetectionReportRequest) (response *ExportVulDetectionReportResponse, err error) {
    return c.ExportVulDetectionReportWithContext(context.Background(), request)
}

// ExportVulDetectionReport
// This API is used to export the vulnerability detection report.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulDetectionReportWithContext(ctx context.Context, request *ExportVulDetectionReportRequest) (response *ExportVulDetectionReportResponse, err error) {
    if request == nil {
        request = NewExportVulDetectionReportRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulDetectionReport")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulDetectionReport require credential")
    }

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

func NewExportVulEffectHostListRequest() (request *ExportVulEffectHostListRequest) {
    request = &ExportVulEffectHostListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulEffectHostList")
    
    
    return
}

func NewExportVulEffectHostListResponse() (response *ExportVulEffectHostListResponse) {
    response = &ExportVulEffectHostListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulEffectHostList
// This API is used to export the list of hosts affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ExportVulEffectHostList(request *ExportVulEffectHostListRequest) (response *ExportVulEffectHostListResponse, err error) {
    return c.ExportVulEffectHostListWithContext(context.Background(), request)
}

// ExportVulEffectHostList
// This API is used to export the list of hosts affected by vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ExportVulEffectHostListWithContext(ctx context.Context, request *ExportVulEffectHostListRequest) (response *ExportVulEffectHostListResponse, err error) {
    if request == nil {
        request = NewExportVulEffectHostListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulEffectHostList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulEffectHostList require credential")
    }

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

func NewExportVulInfoRequest() (request *ExportVulInfoRequest) {
    request = &ExportVulInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulInfo")
    
    
    return
}

func NewExportVulInfoResponse() (response *ExportVulInfoResponse) {
    response = &ExportVulInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulInfo
// This API is used to export the vulnerability information, including the list of affected hosts and component information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ExportVulInfo(request *ExportVulInfoRequest) (response *ExportVulInfoResponse, err error) {
    return c.ExportVulInfoWithContext(context.Background(), request)
}

// ExportVulInfo
// This API is used to export the vulnerability information, including the list of affected hosts and component information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ExportVulInfoWithContext(ctx context.Context, request *ExportVulInfoRequest) (response *ExportVulInfoResponse, err error) {
    if request == nil {
        request = NewExportVulInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulInfo require credential")
    }

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

func NewExportVulListRequest() (request *ExportVulListRequest) {
    request = &ExportVulListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ExportVulList")
    
    
    return
}

func NewExportVulListResponse() (response *ExportVulListResponse) {
    response = &ExportVulListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ExportVulList
// This API is used to export the vulnerability list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulList(request *ExportVulListRequest) (response *ExportVulListResponse, err error) {
    return c.ExportVulListWithContext(context.Background(), request)
}

// ExportVulList
// This API is used to export the vulnerability list.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ExportVulListWithContext(ctx context.Context, request *ExportVulListRequest) (response *ExportVulListResponse, err error) {
    if request == nil {
        request = NewExportVulListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ExportVulList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ExportVulList require credential")
    }

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

func NewGetLocalStorageItemRequest() (request *GetLocalStorageItemRequest) {
    request = &GetLocalStorageItemRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "GetLocalStorageItem")
    
    
    return
}

func NewGetLocalStorageItemResponse() (response *GetLocalStorageItemResponse) {
    response = &GetLocalStorageItemResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// GetLocalStorageItem
// This API is used to obtain the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) GetLocalStorageItem(request *GetLocalStorageItemRequest) (response *GetLocalStorageItemResponse, err error) {
    return c.GetLocalStorageItemWithContext(context.Background(), request)
}

// GetLocalStorageItem
// This API is used to obtain the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) GetLocalStorageItemWithContext(ctx context.Context, request *GetLocalStorageItemRequest) (response *GetLocalStorageItemResponse, err error) {
    if request == nil {
        request = NewGetLocalStorageItemRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "GetLocalStorageItem")
    
    if c.GetCredential() == nil {
        return nil, errors.New("GetLocalStorageItem require credential")
    }

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

func NewIgnoreImpactedHostsRequest() (request *IgnoreImpactedHostsRequest) {
    request = &IgnoreImpactedHostsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "IgnoreImpactedHosts")
    
    
    return
}

func NewIgnoreImpactedHostsResponse() (response *IgnoreImpactedHostsResponse) {
    response = &IgnoreImpactedHostsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// IgnoreImpactedHosts
// This API is used to ignore vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) IgnoreImpactedHosts(request *IgnoreImpactedHostsRequest) (response *IgnoreImpactedHostsResponse, err error) {
    return c.IgnoreImpactedHostsWithContext(context.Background(), request)
}

// IgnoreImpactedHosts
// This API is used to ignore vulnerabilities.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) IgnoreImpactedHostsWithContext(ctx context.Context, request *IgnoreImpactedHostsRequest) (response *IgnoreImpactedHostsResponse, err error) {
    if request == nil {
        request = NewIgnoreImpactedHostsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "IgnoreImpactedHosts")
    
    if c.GetCredential() == nil {
        return nil, errors.New("IgnoreImpactedHosts require credential")
    }

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

func NewKeysLocalStorageRequest() (request *KeysLocalStorageRequest) {
    request = &KeysLocalStorageRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "KeysLocalStorage")
    
    
    return
}

func NewKeysLocalStorageResponse() (response *KeysLocalStorageResponse) {
    response = &KeysLocalStorageResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// KeysLocalStorage
// This API is used to obtain the list of locally stored key values.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) KeysLocalStorage(request *KeysLocalStorageRequest) (response *KeysLocalStorageResponse, err error) {
    return c.KeysLocalStorageWithContext(context.Background(), request)
}

// KeysLocalStorage
// This API is used to obtain the list of locally stored key values.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) KeysLocalStorageWithContext(ctx context.Context, request *KeysLocalStorageRequest) (response *KeysLocalStorageResponse, err error) {
    if request == nil {
        request = NewKeysLocalStorageRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "KeysLocalStorage")
    
    if c.GetCredential() == nil {
        return nil, errors.New("KeysLocalStorage require credential")
    }

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

func NewModifyAutoOpenProVersionConfigRequest() (request *ModifyAutoOpenProVersionConfigRequest) {
    request = &ModifyAutoOpenProVersionConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyAutoOpenProVersionConfig")
    
    
    return
}

func NewModifyAutoOpenProVersionConfigResponse() (response *ModifyAutoOpenProVersionConfigResponse) {
    response = &ModifyAutoOpenProVersionConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyAutoOpenProVersionConfig
// This API is used to enable the configuration of automatically enabling the professional protection configuration for newly added hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyAutoOpenProVersionConfig(request *ModifyAutoOpenProVersionConfigRequest) (response *ModifyAutoOpenProVersionConfigResponse, err error) {
    return c.ModifyAutoOpenProVersionConfigWithContext(context.Background(), request)
}

// ModifyAutoOpenProVersionConfig
// This API is used to enable the configuration of automatically enabling the professional protection configuration for newly added hosts.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyAutoOpenProVersionConfigWithContext(ctx context.Context, request *ModifyAutoOpenProVersionConfigRequest) (response *ModifyAutoOpenProVersionConfigResponse, err error) {
    if request == nil {
        request = NewModifyAutoOpenProVersionConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyAutoOpenProVersionConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyAutoOpenProVersionConfig require credential")
    }

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

func NewModifyBanModeRequest() (request *ModifyBanModeRequest) {
    request = &ModifyBanModeRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBanMode")
    
    
    return
}

func NewModifyBanModeResponse() (response *ModifyBanModeResponse) {
    response = &ModifyBanModeResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBanMode
// This API is used to modify the brute-force blocking mode.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyBanMode(request *ModifyBanModeRequest) (response *ModifyBanModeResponse, err error) {
    return c.ModifyBanModeWithContext(context.Background(), request)
}

// ModifyBanMode
// This API is used to modify the brute-force blocking mode.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyBanModeWithContext(ctx context.Context, request *ModifyBanModeRequest) (response *ModifyBanModeResponse, err error) {
    if request == nil {
        request = NewModifyBanModeRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBanMode")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBanMode require credential")
    }

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

func NewModifyBanStatusRequest() (request *ModifyBanStatusRequest) {
    request = &ModifyBanStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBanStatus")
    
    
    return
}

func NewModifyBanStatusResponse() (response *ModifyBanStatusResponse) {
    response = &ModifyBanStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBanStatus
// This API is used to set the block switch status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBanStatus(request *ModifyBanStatusRequest) (response *ModifyBanStatusResponse, err error) {
    return c.ModifyBanStatusWithContext(context.Background(), request)
}

// ModifyBanStatus
// This API is used to set the block switch status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBanStatusWithContext(ctx context.Context, request *ModifyBanStatusRequest) (response *ModifyBanStatusResponse, err error) {
    if request == nil {
        request = NewModifyBanStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBanStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBanStatus require credential")
    }

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

func NewModifyBanWhiteListRequest() (request *ModifyBanWhiteListRequest) {
    request = &ModifyBanWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBanWhiteList")
    
    
    return
}

func NewModifyBanWhiteListResponse() (response *ModifyBanWhiteListResponse) {
    response = &ModifyBanWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBanWhiteList
// This API is used to modify the blocking allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBanWhiteList(request *ModifyBanWhiteListRequest) (response *ModifyBanWhiteListResponse, err error) {
    return c.ModifyBanWhiteListWithContext(context.Background(), request)
}

// ModifyBanWhiteList
// This API is used to modify the blocking allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBanWhiteListWithContext(ctx context.Context, request *ModifyBanWhiteListRequest) (response *ModifyBanWhiteListResponse, err error) {
    if request == nil {
        request = NewModifyBanWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBanWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBanWhiteList require credential")
    }

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

func NewModifyBaselinePolicyRequest() (request *ModifyBaselinePolicyRequest) {
    request = &ModifyBaselinePolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBaselinePolicy")
    
    
    return
}

func NewModifyBaselinePolicyResponse() (response *ModifyBaselinePolicyResponse) {
    response = &ModifyBaselinePolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBaselinePolicy
// This API is used to change the baseline policy settings.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ModifyBaselinePolicy(request *ModifyBaselinePolicyRequest) (response *ModifyBaselinePolicyResponse, err error) {
    return c.ModifyBaselinePolicyWithContext(context.Background(), request)
}

// ModifyBaselinePolicy
// This API is used to change the baseline policy settings.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ModifyBaselinePolicyWithContext(ctx context.Context, request *ModifyBaselinePolicyRequest) (response *ModifyBaselinePolicyResponse, err error) {
    if request == nil {
        request = NewModifyBaselinePolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBaselinePolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBaselinePolicy require credential")
    }

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

func NewModifyBashPolicyRequest() (request *ModifyBashPolicyRequest) {
    request = &ModifyBashPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBashPolicy")
    
    
    return
}

func NewModifyBashPolicyResponse() (response *ModifyBashPolicyResponse) {
    response = &ModifyBashPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBashPolicy
// This API is used to add or modify high-risk command policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBashPolicy(request *ModifyBashPolicyRequest) (response *ModifyBashPolicyResponse, err error) {
    return c.ModifyBashPolicyWithContext(context.Background(), request)
}

// ModifyBashPolicy
// This API is used to add or modify high-risk command policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_IPNOVALID = "InvalidParameter.IpNoValid"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETER_RULEHOSTIPERR = "InvalidParameter.RuleHostipErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBashPolicyWithContext(ctx context.Context, request *ModifyBashPolicyRequest) (response *ModifyBashPolicyResponse, err error) {
    if request == nil {
        request = NewModifyBashPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBashPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBashPolicy require credential")
    }

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

func NewModifyBashPolicyStatusRequest() (request *ModifyBashPolicyStatusRequest) {
    request = &ModifyBashPolicyStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBashPolicyStatus")
    
    
    return
}

func NewModifyBashPolicyStatusResponse() (response *ModifyBashPolicyStatusResponse) {
    response = &ModifyBashPolicyStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBashPolicyStatus
// This API is used to switch the statuses of high-risk command policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBashPolicyStatus(request *ModifyBashPolicyStatusRequest) (response *ModifyBashPolicyStatusResponse, err error) {
    return c.ModifyBashPolicyStatusWithContext(context.Background(), request)
}

// ModifyBashPolicyStatus
// This API is used to switch the statuses of high-risk command policies.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyBashPolicyStatusWithContext(ctx context.Context, request *ModifyBashPolicyStatusRequest) (response *ModifyBashPolicyStatusResponse, err error) {
    if request == nil {
        request = NewModifyBashPolicyStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBashPolicyStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBashPolicyStatus require credential")
    }

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

func NewModifyBruteAttackRulesRequest() (request *ModifyBruteAttackRulesRequest) {
    request = &ModifyBruteAttackRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyBruteAttackRules")
    
    
    return
}

func NewModifyBruteAttackRulesResponse() (response *ModifyBruteAttackRulesResponse) {
    response = &ModifyBruteAttackRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyBruteAttackRules
// This API is used to modify brute force cracking rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyBruteAttackRules(request *ModifyBruteAttackRulesRequest) (response *ModifyBruteAttackRulesResponse, err error) {
    return c.ModifyBruteAttackRulesWithContext(context.Background(), request)
}

// ModifyBruteAttackRules
// This API is used to modify brute force cracking rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyBruteAttackRulesWithContext(ctx context.Context, request *ModifyBruteAttackRulesRequest) (response *ModifyBruteAttackRulesResponse, err error) {
    if request == nil {
        request = NewModifyBruteAttackRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyBruteAttackRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyBruteAttackRules require credential")
    }

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

func NewModifyEventAttackStatusRequest() (request *ModifyEventAttackStatusRequest) {
    request = &ModifyEventAttackStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyEventAttackStatus")
    
    
    return
}

func NewModifyEventAttackStatusResponse() (response *ModifyEventAttackStatusResponse) {
    response = &ModifyEventAttackStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyEventAttackStatus
// This API is used to modify the status of network attack events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyEventAttackStatus(request *ModifyEventAttackStatusRequest) (response *ModifyEventAttackStatusResponse, err error) {
    return c.ModifyEventAttackStatusWithContext(context.Background(), request)
}

// ModifyEventAttackStatus
// This API is used to modify the status of network attack events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyEventAttackStatusWithContext(ctx context.Context, request *ModifyEventAttackStatusRequest) (response *ModifyEventAttackStatusResponse, err error) {
    if request == nil {
        request = NewModifyEventAttackStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyEventAttackStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyEventAttackStatus require credential")
    }

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

func NewModifyFileTamperEventsRequest() (request *ModifyFileTamperEventsRequest) {
    request = &ModifyFileTamperEventsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyFileTamperEvents")
    
    
    return
}

func NewModifyFileTamperEventsResponse() (response *ModifyFileTamperEventsResponse) {
    response = &ModifyFileTamperEventsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyFileTamperEvents
// This API is used to update the core file events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyFileTamperEvents(request *ModifyFileTamperEventsRequest) (response *ModifyFileTamperEventsResponse, err error) {
    return c.ModifyFileTamperEventsWithContext(context.Background(), request)
}

// ModifyFileTamperEvents
// This API is used to update the core file events.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyFileTamperEventsWithContext(ctx context.Context, request *ModifyFileTamperEventsRequest) (response *ModifyFileTamperEventsResponse, err error) {
    if request == nil {
        request = NewModifyFileTamperEventsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyFileTamperEvents")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyFileTamperEvents require credential")
    }

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

func NewModifyFileTamperRuleRequest() (request *ModifyFileTamperRuleRequest) {
    request = &ModifyFileTamperRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyFileTamperRule")
    
    
    return
}

func NewModifyFileTamperRuleResponse() (response *ModifyFileTamperRuleResponse) {
    response = &ModifyFileTamperRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyFileTamperRule
// This API is used to edit and add core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) ModifyFileTamperRule(request *ModifyFileTamperRuleRequest) (response *ModifyFileTamperRuleResponse, err error) {
    return c.ModifyFileTamperRuleWithContext(context.Background(), request)
}

// ModifyFileTamperRule
// This API is used to edit and add core file monitoring rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  UNKNOWNPARAMETER = "UnknownParameter"
func (c *Client) ModifyFileTamperRuleWithContext(ctx context.Context, request *ModifyFileTamperRuleRequest) (response *ModifyFileTamperRuleResponse, err error) {
    if request == nil {
        request = NewModifyFileTamperRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyFileTamperRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyFileTamperRule require credential")
    }

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

func NewModifyFileTamperRuleStatusRequest() (request *ModifyFileTamperRuleStatusRequest) {
    request = &ModifyFileTamperRuleStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyFileTamperRuleStatus")
    
    
    return
}

func NewModifyFileTamperRuleStatusResponse() (response *ModifyFileTamperRuleStatusResponse) {
    response = &ModifyFileTamperRuleStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyFileTamperRuleStatus
// This API is used to update the core file rule status (batch deletion and disabling supported).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyFileTamperRuleStatus(request *ModifyFileTamperRuleStatusRequest) (response *ModifyFileTamperRuleStatusResponse, err error) {
    return c.ModifyFileTamperRuleStatusWithContext(context.Background(), request)
}

// ModifyFileTamperRuleStatus
// This API is used to update the core file rule status (batch deletion and disabling supported).
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyFileTamperRuleStatusWithContext(ctx context.Context, request *ModifyFileTamperRuleStatusRequest) (response *ModifyFileTamperRuleStatusResponse, err error) {
    if request == nil {
        request = NewModifyFileTamperRuleStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyFileTamperRuleStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyFileTamperRuleStatus require credential")
    }

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

func NewModifyJavaMemShellPluginSwitchRequest() (request *ModifyJavaMemShellPluginSwitchRequest) {
    request = &ModifyJavaMemShellPluginSwitchRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyJavaMemShellPluginSwitch")
    
    
    return
}

func NewModifyJavaMemShellPluginSwitchResponse() (response *ModifyJavaMemShellPluginSwitchResponse) {
    response = &ModifyJavaMemShellPluginSwitchResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyJavaMemShellPluginSwitch
// This API is used to enable and disable Java webshell plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyJavaMemShellPluginSwitch(request *ModifyJavaMemShellPluginSwitchRequest) (response *ModifyJavaMemShellPluginSwitchResponse, err error) {
    return c.ModifyJavaMemShellPluginSwitchWithContext(context.Background(), request)
}

// ModifyJavaMemShellPluginSwitch
// This API is used to enable and disable Java webshell plugins.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyJavaMemShellPluginSwitchWithContext(ctx context.Context, request *ModifyJavaMemShellPluginSwitchRequest) (response *ModifyJavaMemShellPluginSwitchResponse, err error) {
    if request == nil {
        request = NewModifyJavaMemShellPluginSwitchRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyJavaMemShellPluginSwitch")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyJavaMemShellPluginSwitch require credential")
    }

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

func NewModifyJavaMemShellsStatusRequest() (request *ModifyJavaMemShellsStatusRequest) {
    request = &ModifyJavaMemShellsStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyJavaMemShellsStatus")
    
    
    return
}

func NewModifyJavaMemShellsStatusResponse() (response *ModifyJavaMemShellsStatusResponse) {
    response = &ModifyJavaMemShellsStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyJavaMemShellsStatus
// This API is used to modify the Java webshell event status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyJavaMemShellsStatus(request *ModifyJavaMemShellsStatusRequest) (response *ModifyJavaMemShellsStatusResponse, err error) {
    return c.ModifyJavaMemShellsStatusWithContext(context.Background(), request)
}

// ModifyJavaMemShellsStatus
// This API is used to modify the Java webshell event status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyJavaMemShellsStatusWithContext(ctx context.Context, request *ModifyJavaMemShellsStatusRequest) (response *ModifyJavaMemShellsStatusResponse, err error) {
    if request == nil {
        request = NewModifyJavaMemShellsStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyJavaMemShellsStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyJavaMemShellsStatus require credential")
    }

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

func NewModifyLicenseBindsRequest() (request *ModifyLicenseBindsRequest) {
    request = &ModifyLicenseBindsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLicenseBinds")
    
    
    return
}

func NewModifyLicenseBindsResponse() (response *ModifyLicenseBindsResponse) {
    response = &ModifyLicenseBindsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLicenseBinds
// This API is used to bind machines to an authorization in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLicenseBinds(request *ModifyLicenseBindsRequest) (response *ModifyLicenseBindsResponse, err error) {
    return c.ModifyLicenseBindsWithContext(context.Background(), request)
}

// ModifyLicenseBinds
// This API is used to bind machines to an authorization in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLicenseBindsWithContext(ctx context.Context, request *ModifyLicenseBindsRequest) (response *ModifyLicenseBindsResponse, err error) {
    if request == nil {
        request = NewModifyLicenseBindsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLicenseBinds")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLicenseBinds require credential")
    }

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

func NewModifyLicenseOrderRequest() (request *ModifyLicenseOrderRequest) {
    request = &ModifyLicenseOrderRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLicenseOrder")
    
    
    return
}

func NewModifyLicenseOrderResponse() (response *ModifyLicenseOrderResponse) {
    response = &ModifyLicenseOrderResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLicenseOrder
// This API is used to edit CWPP - pay-as-you-go authorization orders.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLicenseOrder(request *ModifyLicenseOrderRequest) (response *ModifyLicenseOrderResponse, err error) {
    return c.ModifyLicenseOrderWithContext(context.Background(), request)
}

// ModifyLicenseOrder
// This API is used to edit CWPP - pay-as-you-go authorization orders.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLicenseOrderWithContext(ctx context.Context, request *ModifyLicenseOrderRequest) (response *ModifyLicenseOrderResponse, err error) {
    if request == nil {
        request = NewModifyLicenseOrderRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLicenseOrder")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLicenseOrder require credential")
    }

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

func NewModifyLogKafkaAccessRequest() (request *ModifyLogKafkaAccessRequest) {
    request = &ModifyLogKafkaAccessRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLogKafkaAccess")
    
    
    return
}

func NewModifyLogKafkaAccessResponse() (response *ModifyLogKafkaAccessResponse) {
    response = &ModifyLogKafkaAccessResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLogKafkaAccess
// This API is used to add or modify the access configuration of logs shipped to Kafka.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaAccess(request *ModifyLogKafkaAccessRequest) (response *ModifyLogKafkaAccessResponse, err error) {
    return c.ModifyLogKafkaAccessWithContext(context.Background(), request)
}

// ModifyLogKafkaAccess
// This API is used to add or modify the access configuration of logs shipped to Kafka.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaAccessWithContext(ctx context.Context, request *ModifyLogKafkaAccessRequest) (response *ModifyLogKafkaAccessResponse, err error) {
    if request == nil {
        request = NewModifyLogKafkaAccessRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLogKafkaAccess")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLogKafkaAccess require credential")
    }

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

func NewModifyLogKafkaDeliverTypeRequest() (request *ModifyLogKafkaDeliverTypeRequest) {
    request = &ModifyLogKafkaDeliverTypeRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLogKafkaDeliverType")
    
    
    return
}

func NewModifyLogKafkaDeliverTypeResponse() (response *ModifyLogKafkaDeliverTypeResponse) {
    response = &ModifyLogKafkaDeliverTypeResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLogKafkaDeliverType
// This API is used to modify the shipping configuration and switch of the specified log category.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaDeliverType(request *ModifyLogKafkaDeliverTypeRequest) (response *ModifyLogKafkaDeliverTypeResponse, err error) {
    return c.ModifyLogKafkaDeliverTypeWithContext(context.Background(), request)
}

// ModifyLogKafkaDeliverType
// This API is used to modify the shipping configuration and switch of the specified log category.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaDeliverTypeWithContext(ctx context.Context, request *ModifyLogKafkaDeliverTypeRequest) (response *ModifyLogKafkaDeliverTypeResponse, err error) {
    if request == nil {
        request = NewModifyLogKafkaDeliverTypeRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLogKafkaDeliverType")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLogKafkaDeliverType require credential")
    }

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

func NewModifyLogKafkaStateRequest() (request *ModifyLogKafkaStateRequest) {
    request = &ModifyLogKafkaStateRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLogKafkaState")
    
    
    return
}

func NewModifyLogKafkaStateResponse() (response *ModifyLogKafkaStateResponse) {
    response = &ModifyLogKafkaStateResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLogKafkaState
// This API is used to modify the information of log shipping statuses.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaState(request *ModifyLogKafkaStateRequest) (response *ModifyLogKafkaStateResponse, err error) {
    return c.ModifyLogKafkaStateWithContext(context.Background(), request)
}

// ModifyLogKafkaState
// This API is used to modify the information of log shipping statuses.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyLogKafkaStateWithContext(ctx context.Context, request *ModifyLogKafkaStateRequest) (response *ModifyLogKafkaStateResponse, err error) {
    if request == nil {
        request = NewModifyLogKafkaStateRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLogKafkaState")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLogKafkaState require credential")
    }

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

func NewModifyLogStorageConfigRequest() (request *ModifyLogStorageConfigRequest) {
    request = &ModifyLogStorageConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLogStorageConfig")
    
    
    return
}

func NewModifyLogStorageConfigResponse() (response *ModifyLogStorageConfigResponse) {
    response = &ModifyLogStorageConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLogStorageConfig
// This API is used to modify the log storage configuration.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ModifyLogStorageConfig(request *ModifyLogStorageConfigRequest) (response *ModifyLogStorageConfigResponse, err error) {
    return c.ModifyLogStorageConfigWithContext(context.Background(), request)
}

// ModifyLogStorageConfig
// This API is used to modify the log storage configuration.
//
// error code that may be returned:
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ModifyLogStorageConfigWithContext(ctx context.Context, request *ModifyLogStorageConfigRequest) (response *ModifyLogStorageConfigResponse, err error) {
    if request == nil {
        request = NewModifyLogStorageConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLogStorageConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLogStorageConfig require credential")
    }

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

func NewModifyLoginWhiteInfoRequest() (request *ModifyLoginWhiteInfoRequest) {
    request = &ModifyLoginWhiteInfoRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLoginWhiteInfo")
    
    
    return
}

func NewModifyLoginWhiteInfoResponse() (response *ModifyLoginWhiteInfoResponse) {
    response = &ModifyLoginWhiteInfoResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLoginWhiteInfo
// This API is used to update the log-in audit allowlist information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyLoginWhiteInfo(request *ModifyLoginWhiteInfoRequest) (response *ModifyLoginWhiteInfoResponse, err error) {
    return c.ModifyLoginWhiteInfoWithContext(context.Background(), request)
}

// ModifyLoginWhiteInfo
// This API is used to update the log-in audit allowlist information.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyLoginWhiteInfoWithContext(ctx context.Context, request *ModifyLoginWhiteInfoRequest) (response *ModifyLoginWhiteInfoResponse, err error) {
    if request == nil {
        request = NewModifyLoginWhiteInfoRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLoginWhiteInfo")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLoginWhiteInfo require credential")
    }

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

func NewModifyLoginWhiteRecordRequest() (request *ModifyLoginWhiteRecordRequest) {
    request = &ModifyLoginWhiteRecordRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyLoginWhiteRecord")
    
    
    return
}

func NewModifyLoginWhiteRecordResponse() (response *ModifyLoginWhiteRecordResponse) {
    response = &ModifyLoginWhiteRecordResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyLoginWhiteRecord
// This API is used to update the log-in audit allowlist information. (The number of server lists needs to be less than 1,000.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyLoginWhiteRecord(request *ModifyLoginWhiteRecordRequest) (response *ModifyLoginWhiteRecordResponse, err error) {
    return c.ModifyLoginWhiteRecordWithContext(context.Background(), request)
}

// ModifyLoginWhiteRecord
// This API is used to update the log-in audit allowlist information. (The number of server lists needs to be less than 1,000.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_RULEHOSTDUPLICATEERR = "InvalidParameter.RuleHostDuplicateErr"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyLoginWhiteRecordWithContext(ctx context.Context, request *ModifyLoginWhiteRecordRequest) (response *ModifyLoginWhiteRecordResponse, err error) {
    if request == nil {
        request = NewModifyLoginWhiteRecordRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyLoginWhiteRecord")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyLoginWhiteRecord require credential")
    }

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

func NewModifyMachineAutoClearConfigRequest() (request *ModifyMachineAutoClearConfigRequest) {
    request = &ModifyMachineAutoClearConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyMachineAutoClearConfig")
    
    
    return
}

func NewModifyMachineAutoClearConfigResponse() (response *ModifyMachineAutoClearConfigResponse) {
    response = &ModifyMachineAutoClearConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyMachineAutoClearConfig
// This API is used to modify the cleanup configuration of the machine.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyMachineAutoClearConfig(request *ModifyMachineAutoClearConfigRequest) (response *ModifyMachineAutoClearConfigResponse, err error) {
    return c.ModifyMachineAutoClearConfigWithContext(context.Background(), request)
}

// ModifyMachineAutoClearConfig
// This API is used to modify the cleanup configuration of the machine.
//
// error code that may be returned:
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyMachineAutoClearConfigWithContext(ctx context.Context, request *ModifyMachineAutoClearConfigRequest) (response *ModifyMachineAutoClearConfigResponse, err error) {
    if request == nil {
        request = NewModifyMachineAutoClearConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyMachineAutoClearConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyMachineAutoClearConfig require credential")
    }

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

func NewModifyMaliciousRequestWhiteListRequest() (request *ModifyMaliciousRequestWhiteListRequest) {
    request = &ModifyMaliciousRequestWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyMaliciousRequestWhiteList")
    
    
    return
}

func NewModifyMaliciousRequestWhiteListResponse() (response *ModifyMaliciousRequestWhiteListResponse) {
    response = &ModifyMaliciousRequestWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyMaliciousRequestWhiteList
// This API is used to update the malicious request allowlist.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ModifyMaliciousRequestWhiteList(request *ModifyMaliciousRequestWhiteListRequest) (response *ModifyMaliciousRequestWhiteListResponse, err error) {
    return c.ModifyMaliciousRequestWhiteListWithContext(context.Background(), request)
}

// ModifyMaliciousRequestWhiteList
// This API is used to update the malicious request allowlist.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) ModifyMaliciousRequestWhiteListWithContext(ctx context.Context, request *ModifyMaliciousRequestWhiteListRequest) (response *ModifyMaliciousRequestWhiteListResponse, err error) {
    if request == nil {
        request = NewModifyMaliciousRequestWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyMaliciousRequestWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyMaliciousRequestWhiteList require credential")
    }

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

func NewModifyMalwareTimingScanSettingsRequest() (request *ModifyMalwareTimingScanSettingsRequest) {
    request = &ModifyMalwareTimingScanSettingsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyMalwareTimingScanSettings")
    
    
    return
}

func NewModifyMalwareTimingScanSettingsResponse() (response *ModifyMalwareTimingScanSettingsResponse) {
    response = &ModifyMalwareTimingScanSettingsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyMalwareTimingScanSettings
// This API is used to set scheduled scan.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyMalwareTimingScanSettings(request *ModifyMalwareTimingScanSettingsRequest) (response *ModifyMalwareTimingScanSettingsResponse, err error) {
    return c.ModifyMalwareTimingScanSettingsWithContext(context.Background(), request)
}

// ModifyMalwareTimingScanSettings
// This API is used to set scheduled scan.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyMalwareTimingScanSettingsWithContext(ctx context.Context, request *ModifyMalwareTimingScanSettingsRequest) (response *ModifyMalwareTimingScanSettingsResponse, err error) {
    if request == nil {
        request = NewModifyMalwareTimingScanSettingsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyMalwareTimingScanSettings")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyMalwareTimingScanSettings require credential")
    }

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

func NewModifyMalwareWhiteListRequest() (request *ModifyMalwareWhiteListRequest) {
    request = &ModifyMalwareWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyMalwareWhiteList")
    
    
    return
}

func NewModifyMalwareWhiteListResponse() (response *ModifyMalwareWhiteListResponse) {
    response = &ModifyMalwareWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyMalwareWhiteList
// This API is used to edit the Trojan allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) ModifyMalwareWhiteList(request *ModifyMalwareWhiteListRequest) (response *ModifyMalwareWhiteListResponse, err error) {
    return c.ModifyMalwareWhiteListWithContext(context.Background(), request)
}

// ModifyMalwareWhiteList
// This API is used to edit the Trojan allowlist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) ModifyMalwareWhiteListWithContext(ctx context.Context, request *ModifyMalwareWhiteListRequest) (response *ModifyMalwareWhiteListResponse, err error) {
    if request == nil {
        request = NewModifyMalwareWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyMalwareWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyMalwareWhiteList require credential")
    }

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

func NewModifyNetAttackSettingRequest() (request *ModifyNetAttackSettingRequest) {
    request = &ModifyNetAttackSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyNetAttackSetting")
    
    
    return
}

func NewModifyNetAttackSettingResponse() (response *ModifyNetAttackSettingResponse) {
    response = &ModifyNetAttackSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyNetAttackSetting
// This API is used to modify network attack settings.
//
// error code that may be returned:
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyNetAttackSetting(request *ModifyNetAttackSettingRequest) (response *ModifyNetAttackSettingResponse, err error) {
    return c.ModifyNetAttackSettingWithContext(context.Background(), request)
}

// ModifyNetAttackSetting
// This API is used to modify network attack settings.
//
// error code that may be returned:
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyNetAttackSettingWithContext(ctx context.Context, request *ModifyNetAttackSettingRequest) (response *ModifyNetAttackSettingResponse, err error) {
    if request == nil {
        request = NewModifyNetAttackSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyNetAttackSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyNetAttackSetting require credential")
    }

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

func NewModifyNetAttackWhiteListRequest() (request *ModifyNetAttackWhiteListRequest) {
    request = &ModifyNetAttackWhiteListRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyNetAttackWhiteList")
    
    
    return
}

func NewModifyNetAttackWhiteListResponse() (response *ModifyNetAttackWhiteListResponse) {
    response = &ModifyNetAttackWhiteListResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyNetAttackWhiteList
// This API is used to edit the network attack whitelist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) ModifyNetAttackWhiteList(request *ModifyNetAttackWhiteListRequest) (response *ModifyNetAttackWhiteListResponse, err error) {
    return c.ModifyNetAttackWhiteListWithContext(context.Background(), request)
}

// ModifyNetAttackWhiteList
// This API is used to edit the network attack whitelist.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
func (c *Client) ModifyNetAttackWhiteListWithContext(ctx context.Context, request *ModifyNetAttackWhiteListRequest) (response *ModifyNetAttackWhiteListResponse, err error) {
    if request == nil {
        request = NewModifyNetAttackWhiteListRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyNetAttackWhiteList")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyNetAttackWhiteList require credential")
    }

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

func NewModifyRansomDefenseEventsStatusRequest() (request *ModifyRansomDefenseEventsStatusRequest) {
    request = &ModifyRansomDefenseEventsStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyRansomDefenseEventsStatus")
    
    
    return
}

func NewModifyRansomDefenseEventsStatusResponse() (response *ModifyRansomDefenseEventsStatusResponse) {
    response = &ModifyRansomDefenseEventsStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyRansomDefenseEventsStatus
// This API is used to modify the status of anti-ransomware events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyRansomDefenseEventsStatus(request *ModifyRansomDefenseEventsStatusRequest) (response *ModifyRansomDefenseEventsStatusResponse, err error) {
    return c.ModifyRansomDefenseEventsStatusWithContext(context.Background(), request)
}

// ModifyRansomDefenseEventsStatus
// This API is used to modify the status of anti-ransomware events.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyRansomDefenseEventsStatusWithContext(ctx context.Context, request *ModifyRansomDefenseEventsStatusRequest) (response *ModifyRansomDefenseEventsStatusResponse, err error) {
    if request == nil {
        request = NewModifyRansomDefenseEventsStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyRansomDefenseEventsStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyRansomDefenseEventsStatus require credential")
    }

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

func NewModifyRansomDefenseStrategyStatusRequest() (request *ModifyRansomDefenseStrategyStatusRequest) {
    request = &ModifyRansomDefenseStrategyStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyRansomDefenseStrategyStatus")
    
    
    return
}

func NewModifyRansomDefenseStrategyStatusResponse() (response *ModifyRansomDefenseStrategyStatusResponse) {
    response = &ModifyRansomDefenseStrategyStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyRansomDefenseStrategyStatus
// This API is used to modify the anti-ransomware policy status in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyRansomDefenseStrategyStatus(request *ModifyRansomDefenseStrategyStatusRequest) (response *ModifyRansomDefenseStrategyStatusResponse, err error) {
    return c.ModifyRansomDefenseStrategyStatusWithContext(context.Background(), request)
}

// ModifyRansomDefenseStrategyStatus
// This API is used to modify the anti-ransomware policy status in batches.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyRansomDefenseStrategyStatusWithContext(ctx context.Context, request *ModifyRansomDefenseStrategyStatusRequest) (response *ModifyRansomDefenseStrategyStatusResponse, err error) {
    if request == nil {
        request = NewModifyRansomDefenseStrategyStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyRansomDefenseStrategyStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyRansomDefenseStrategyStatus require credential")
    }

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

func NewModifyRiskDnsPolicyRequest() (request *ModifyRiskDnsPolicyRequest) {
    request = &ModifyRiskDnsPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyRiskDnsPolicy")
    
    
    return
}

func NewModifyRiskDnsPolicyResponse() (response *ModifyRiskDnsPolicyResponse) {
    response = &ModifyRiskDnsPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyRiskDnsPolicy
// This API is used to modify malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ModifyRiskDnsPolicy(request *ModifyRiskDnsPolicyRequest) (response *ModifyRiskDnsPolicyResponse, err error) {
    return c.ModifyRiskDnsPolicyWithContext(context.Background(), request)
}

// ModifyRiskDnsPolicy
// This API is used to modify malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) ModifyRiskDnsPolicyWithContext(ctx context.Context, request *ModifyRiskDnsPolicyRequest) (response *ModifyRiskDnsPolicyResponse, err error) {
    if request == nil {
        request = NewModifyRiskDnsPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyRiskDnsPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyRiskDnsPolicy require credential")
    }

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

func NewModifyRiskDnsPolicyStatusRequest() (request *ModifyRiskDnsPolicyStatusRequest) {
    request = &ModifyRiskDnsPolicyStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyRiskDnsPolicyStatus")
    
    
    return
}

func NewModifyRiskDnsPolicyStatusResponse() (response *ModifyRiskDnsPolicyStatusResponse) {
    response = &ModifyRiskDnsPolicyStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyRiskDnsPolicyStatus
// This API is used to modify the status of malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) ModifyRiskDnsPolicyStatus(request *ModifyRiskDnsPolicyStatusRequest) (response *ModifyRiskDnsPolicyStatusResponse, err error) {
    return c.ModifyRiskDnsPolicyStatusWithContext(context.Background(), request)
}

// ModifyRiskDnsPolicyStatus
// This API is used to modify the status of malicious request policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) ModifyRiskDnsPolicyStatusWithContext(ctx context.Context, request *ModifyRiskDnsPolicyStatusRequest) (response *ModifyRiskDnsPolicyStatusResponse, err error) {
    if request == nil {
        request = NewModifyRiskDnsPolicyStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyRiskDnsPolicyStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyRiskDnsPolicyStatus require credential")
    }

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

func NewModifyRiskEventsStatusRequest() (request *ModifyRiskEventsStatusRequest) {
    request = &ModifyRiskEventsStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyRiskEventsStatus")
    
    
    return
}

func NewModifyRiskEventsStatusResponse() (response *ModifyRiskEventsStatusResponse) {
    response = &ModifyRiskEventsStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyRiskEventsStatus
// This API is used to change the status of intrusion detection events, including virus scanning, abnormal log-ins, password cracking, high-risk commands, reverse shells, and local privilege escalations.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyRiskEventsStatus(request *ModifyRiskEventsStatusRequest) (response *ModifyRiskEventsStatusResponse, err error) {
    return c.ModifyRiskEventsStatusWithContext(context.Background(), request)
}

// ModifyRiskEventsStatus
// This API is used to change the status of intrusion detection events, including virus scanning, abnormal log-ins, password cracking, high-risk commands, reverse shells, and local privilege escalations.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyRiskEventsStatusWithContext(ctx context.Context, request *ModifyRiskEventsStatusRequest) (response *ModifyRiskEventsStatusResponse, err error) {
    if request == nil {
        request = NewModifyRiskEventsStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyRiskEventsStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyRiskEventsStatus require credential")
    }

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

func NewModifyUsersConfigRequest() (request *ModifyUsersConfigRequest) {
    request = &ModifyUsersConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyUsersConfig")
    
    
    return
}

func NewModifyUsersConfigResponse() (response *ModifyUsersConfigResponse) {
    response = &ModifyUsersConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyUsersConfig
// This API is used to create or modify user custom settings.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyUsersConfig(request *ModifyUsersConfigRequest) (response *ModifyUsersConfigResponse, err error) {
    return c.ModifyUsersConfigWithContext(context.Background(), request)
}

// ModifyUsersConfig
// This API is used to create or modify user custom settings.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  AUTHFAILURE_UNAUTHORIZEDOPERATION = "AuthFailure.UnauthorizedOperation"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  OPERATIONDENIED = "OperationDenied"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) ModifyUsersConfigWithContext(ctx context.Context, request *ModifyUsersConfigRequest) (response *ModifyUsersConfigResponse, err error) {
    if request == nil {
        request = NewModifyUsersConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyUsersConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyUsersConfig require credential")
    }

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

func NewModifyVulDefenceEventStatusRequest() (request *ModifyVulDefenceEventStatusRequest) {
    request = &ModifyVulDefenceEventStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyVulDefenceEventStatus")
    
    
    return
}

func NewModifyVulDefenceEventStatusResponse() (response *ModifyVulDefenceEventStatusResponse) {
    response = &ModifyVulDefenceEventStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyVulDefenceEventStatus
// This API is used to change the vulnerability defense event status. (Vulnerability fixing is carried out using another API.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyVulDefenceEventStatus(request *ModifyVulDefenceEventStatusRequest) (response *ModifyVulDefenceEventStatusResponse, err error) {
    return c.ModifyVulDefenceEventStatusWithContext(context.Background(), request)
}

// ModifyVulDefenceEventStatus
// This API is used to change the vulnerability defense event status. (Vulnerability fixing is carried out using another API.)
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyVulDefenceEventStatusWithContext(ctx context.Context, request *ModifyVulDefenceEventStatusRequest) (response *ModifyVulDefenceEventStatusResponse, err error) {
    if request == nil {
        request = NewModifyVulDefenceEventStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyVulDefenceEventStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyVulDefenceEventStatus require credential")
    }

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

func NewModifyVulDefenceSettingRequest() (request *ModifyVulDefenceSettingRequest) {
    request = &ModifyVulDefenceSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyVulDefenceSetting")
    
    
    return
}

func NewModifyVulDefenceSettingResponse() (response *ModifyVulDefenceSettingResponse) {
    response = &ModifyVulDefenceSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyVulDefenceSetting
// This API is used to modify vulnerability defense plugin settings.
//
// 1) The new settings apply to new hosts automatically. scope is set to 1, and quuids is left blank.
//
// 2) The new settings do not apply to Ultimate Edition hosts. scope is set to 0, and the current QUUID list is specified as the value of quuids.
//
// 3) For a given QUUID list, when scope is set to 0, QUUID selected by the user is specified as the value of quuids.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyVulDefenceSetting(request *ModifyVulDefenceSettingRequest) (response *ModifyVulDefenceSettingResponse, err error) {
    return c.ModifyVulDefenceSettingWithContext(context.Background(), request)
}

// ModifyVulDefenceSetting
// This API is used to modify vulnerability defense plugin settings.
//
// 1) The new settings apply to new hosts automatically. scope is set to 1, and quuids is left blank.
//
// 2) The new settings do not apply to Ultimate Edition hosts. scope is set to 0, and the current QUUID list is specified as the value of quuids.
//
// 3) For a given QUUID list, when scope is set to 0, QUUID selected by the user is specified as the value of quuids.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyVulDefenceSettingWithContext(ctx context.Context, request *ModifyVulDefenceSettingRequest) (response *ModifyVulDefenceSettingResponse, err error) {
    if request == nil {
        request = NewModifyVulDefenceSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyVulDefenceSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyVulDefenceSetting require credential")
    }

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

func NewModifyWarningHostConfigRequest() (request *ModifyWarningHostConfigRequest) {
    request = &ModifyWarningHostConfigRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWarningHostConfig")
    
    
    return
}

func NewModifyWarningHostConfigResponse() (response *ModifyWarningHostConfigResponse) {
    response = &ModifyWarningHostConfigResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWarningHostConfig
// This API is used to modify the alarming machine scope settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWarningHostConfig(request *ModifyWarningHostConfigRequest) (response *ModifyWarningHostConfigResponse, err error) {
    return c.ModifyWarningHostConfigWithContext(context.Background(), request)
}

// ModifyWarningHostConfig
// This API is used to modify the alarming machine scope settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWarningHostConfigWithContext(ctx context.Context, request *ModifyWarningHostConfigRequest) (response *ModifyWarningHostConfigResponse, err error) {
    if request == nil {
        request = NewModifyWarningHostConfigRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWarningHostConfig")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWarningHostConfig require credential")
    }

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

func NewModifyWarningSettingRequest() (request *ModifyWarningSettingRequest) {
    request = &ModifyWarningSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWarningSetting")
    
    
    return
}

func NewModifyWarningSettingResponse() (response *ModifyWarningSettingResponse) {
    response = &ModifyWarningSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWarningSetting
// This API is used to modify alarm settings.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWarningSetting(request *ModifyWarningSettingRequest) (response *ModifyWarningSettingResponse, err error) {
    return c.ModifyWarningSettingWithContext(context.Background(), request)
}

// ModifyWarningSetting
// This API is used to modify alarm settings.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWarningSettingWithContext(ctx context.Context, request *ModifyWarningSettingRequest) (response *ModifyWarningSettingResponse, err error) {
    if request == nil {
        request = NewModifyWarningSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWarningSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWarningSetting require credential")
    }

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

func NewModifyWebHookPolicyRequest() (request *ModifyWebHookPolicyRequest) {
    request = &ModifyWebHookPolicyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebHookPolicy")
    
    
    return
}

func NewModifyWebHookPolicyResponse() (response *ModifyWebHookPolicyResponse) {
    response = &ModifyWebHookPolicyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebHookPolicy
// This API is used to add or modify alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWebHookPolicy(request *ModifyWebHookPolicyRequest) (response *ModifyWebHookPolicyResponse, err error) {
    return c.ModifyWebHookPolicyWithContext(context.Background(), request)
}

// ModifyWebHookPolicy
// This API is used to add or modify alarm policies.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWebHookPolicyWithContext(ctx context.Context, request *ModifyWebHookPolicyRequest) (response *ModifyWebHookPolicyResponse, err error) {
    if request == nil {
        request = NewModifyWebHookPolicyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebHookPolicy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebHookPolicy require credential")
    }

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

func NewModifyWebHookPolicyStatusRequest() (request *ModifyWebHookPolicyStatusRequest) {
    request = &ModifyWebHookPolicyStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebHookPolicyStatus")
    
    
    return
}

func NewModifyWebHookPolicyStatusResponse() (response *ModifyWebHookPolicyStatusResponse) {
    response = &ModifyWebHookPolicyStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebHookPolicyStatus
// This API is used to modify the alarm policy switch.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWebHookPolicyStatus(request *ModifyWebHookPolicyStatusRequest) (response *ModifyWebHookPolicyStatusResponse, err error) {
    return c.ModifyWebHookPolicyStatusWithContext(context.Background(), request)
}

// ModifyWebHookPolicyStatus
// This API is used to modify the alarm policy switch.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ModifyWebHookPolicyStatusWithContext(ctx context.Context, request *ModifyWebHookPolicyStatusRequest) (response *ModifyWebHookPolicyStatusResponse, err error) {
    if request == nil {
        request = NewModifyWebHookPolicyStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebHookPolicyStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebHookPolicyStatus require credential")
    }

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

func NewModifyWebHookReceiverRequest() (request *ModifyWebHookReceiverRequest) {
    request = &ModifyWebHookReceiverRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebHookReceiver")
    
    
    return
}

func NewModifyWebHookReceiverResponse() (response *ModifyWebHookReceiverResponse) {
    response = &ModifyWebHookReceiverResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebHookReceiver
// This API is used to add or update the alarm recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
func (c *Client) ModifyWebHookReceiver(request *ModifyWebHookReceiverRequest) (response *ModifyWebHookReceiverResponse, err error) {
    return c.ModifyWebHookReceiverWithContext(context.Background(), request)
}

// ModifyWebHookReceiver
// This API is used to add or update the alarm recipient.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
func (c *Client) ModifyWebHookReceiverWithContext(ctx context.Context, request *ModifyWebHookReceiverRequest) (response *ModifyWebHookReceiverResponse, err error) {
    if request == nil {
        request = NewModifyWebHookReceiverRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebHookReceiver")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebHookReceiver require credential")
    }

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

func NewModifyWebHookRuleRequest() (request *ModifyWebHookRuleRequest) {
    request = &ModifyWebHookRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebHookRule")
    
    
    return
}

func NewModifyWebHookRuleResponse() (response *ModifyWebHookRuleResponse) {
    response = &ModifyWebHookRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebHookRule
// This API is used to add or modify the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebHookRule(request *ModifyWebHookRuleRequest) (response *ModifyWebHookRuleResponse, err error) {
    return c.ModifyWebHookRuleWithContext(context.Background(), request)
}

// ModifyWebHookRule
// This API is used to add or modify the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebHookRuleWithContext(ctx context.Context, request *ModifyWebHookRuleRequest) (response *ModifyWebHookRuleResponse, err error) {
    if request == nil {
        request = NewModifyWebHookRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebHookRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebHookRule require credential")
    }

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

func NewModifyWebHookRuleStatusRequest() (request *ModifyWebHookRuleStatusRequest) {
    request = &ModifyWebHookRuleStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebHookRuleStatus")
    
    
    return
}

func NewModifyWebHookRuleStatusResponse() (response *ModifyWebHookRuleStatusResponse) {
    response = &ModifyWebHookRuleStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebHookRuleStatus
// This API is used to modify the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebHookRuleStatus(request *ModifyWebHookRuleStatusRequest) (response *ModifyWebHookRuleStatusResponse, err error) {
    return c.ModifyWebHookRuleStatusWithContext(context.Background(), request)
}

// ModifyWebHookRuleStatus
// This API is used to modify the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebHookRuleStatusWithContext(ctx context.Context, request *ModifyWebHookRuleStatusRequest) (response *ModifyWebHookRuleStatusResponse, err error) {
    if request == nil {
        request = NewModifyWebHookRuleStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebHookRuleStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebHookRuleStatus require credential")
    }

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

func NewModifyWebPageProtectSwitchRequest() (request *ModifyWebPageProtectSwitchRequest) {
    request = &ModifyWebPageProtectSwitchRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ModifyWebPageProtectSwitch")
    
    
    return
}

func NewModifyWebPageProtectSwitchResponse() (response *ModifyWebPageProtectSwitchResponse) {
    response = &ModifyWebPageProtectSwitchResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ModifyWebPageProtectSwitch
// This API is used to enable or disable website anti-tampering protection.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  FAILEDOPERATION_LICENSEEXCEEDED = "FailedOperation.LicenseExceeded"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebPageProtectSwitch(request *ModifyWebPageProtectSwitchRequest) (response *ModifyWebPageProtectSwitchResponse, err error) {
    return c.ModifyWebPageProtectSwitchWithContext(context.Background(), request)
}

// ModifyWebPageProtectSwitch
// This API is used to enable or disable website anti-tampering protection.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_AGENTOFFLINE = "FailedOperation.AgentOffline"
//  FAILEDOPERATION_LICENSEEXCEEDED = "FailedOperation.LicenseExceeded"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  LIMITEXCEEDED = "LimitExceeded"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ModifyWebPageProtectSwitchWithContext(ctx context.Context, request *ModifyWebPageProtectSwitchRequest) (response *ModifyWebPageProtectSwitchResponse, err error) {
    if request == nil {
        request = NewModifyWebPageProtectSwitchRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ModifyWebPageProtectSwitch")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ModifyWebPageProtectSwitch require credential")
    }

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

func NewRansomDefenseRollbackRequest() (request *RansomDefenseRollbackRequest) {
    request = &RansomDefenseRollbackRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RansomDefenseRollback")
    
    
    return
}

func NewRansomDefenseRollbackResponse() (response *RansomDefenseRollbackResponse) {
    response = &RansomDefenseRollbackResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RansomDefenseRollback
// This API is used to roll back anti-ransomware snapshots.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) RansomDefenseRollback(request *RansomDefenseRollbackRequest) (response *RansomDefenseRollbackResponse, err error) {
    return c.RansomDefenseRollbackWithContext(context.Background(), request)
}

// RansomDefenseRollback
// This API is used to roll back anti-ransomware snapshots.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) RansomDefenseRollbackWithContext(ctx context.Context, request *RansomDefenseRollbackRequest) (response *RansomDefenseRollbackResponse, err error) {
    if request == nil {
        request = NewRansomDefenseRollbackRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RansomDefenseRollback")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RansomDefenseRollback require credential")
    }

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

func NewRecoverMalwaresRequest() (request *RecoverMalwaresRequest) {
    request = &RecoverMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RecoverMalwares")
    
    
    return
}

func NewRecoverMalwaresResponse() (response *RecoverMalwaresResponse) {
    response = &RecoverMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RecoverMalwares
// This API is used to batch recover quarantined Trojan files.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_RECOVER = "FailedOperation.Recover"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) RecoverMalwares(request *RecoverMalwaresRequest) (response *RecoverMalwaresResponse, err error) {
    return c.RecoverMalwaresWithContext(context.Background(), request)
}

// RecoverMalwares
// This API is used to batch recover quarantined Trojan files.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_RECOVER = "FailedOperation.Recover"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) RecoverMalwaresWithContext(ctx context.Context, request *RecoverMalwaresRequest) (response *RecoverMalwaresResponse, err error) {
    if request == nil {
        request = NewRecoverMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RecoverMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RecoverMalwares require credential")
    }

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

func NewRemoveLocalStorageItemRequest() (request *RemoveLocalStorageItemRequest) {
    request = &RemoveLocalStorageItemRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RemoveLocalStorageItem")
    
    
    return
}

func NewRemoveLocalStorageItemResponse() (response *RemoveLocalStorageItemResponse) {
    response = &RemoveLocalStorageItemResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RemoveLocalStorageItem
// This API is used to delete the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) RemoveLocalStorageItem(request *RemoveLocalStorageItemRequest) (response *RemoveLocalStorageItemResponse, err error) {
    return c.RemoveLocalStorageItemWithContext(context.Background(), request)
}

// RemoveLocalStorageItem
// This API is used to delete the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) RemoveLocalStorageItemWithContext(ctx context.Context, request *RemoveLocalStorageItemRequest) (response *RemoveLocalStorageItemResponse, err error) {
    if request == nil {
        request = NewRemoveLocalStorageItemRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RemoveLocalStorageItem")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RemoveLocalStorageItem require credential")
    }

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

func NewRemoveMachineRequest() (request *RemoveMachineRequest) {
    request = &RemoveMachineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RemoveMachine")
    
    
    return
}

func NewRemoveMachineResponse() (response *RemoveMachineResponse) {
    response = &RemoveMachineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RemoveMachine
// This API is used to delete all records of the host. Currently, it only supports non-Tencent Cloud hosts, and the host needs to be offline.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) RemoveMachine(request *RemoveMachineRequest) (response *RemoveMachineResponse, err error) {
    return c.RemoveMachineWithContext(context.Background(), request)
}

// RemoveMachine
// This API is used to delete all records of the host. Currently, it only supports non-Tencent Cloud hosts, and the host needs to be offline.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  UNSUPPORTEDOPERATION = "UnsupportedOperation"
func (c *Client) RemoveMachineWithContext(ctx context.Context, request *RemoveMachineRequest) (response *RemoveMachineResponse, err error) {
    if request == nil {
        request = NewRemoveMachineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RemoveMachine")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RemoveMachine require credential")
    }

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

func NewRetryCreateSnapshotRequest() (request *RetryCreateSnapshotRequest) {
    request = &RetryCreateSnapshotRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RetryCreateSnapshot")
    
    
    return
}

func NewRetryCreateSnapshotResponse() (response *RetryCreateSnapshotResponse) {
    response = &RetryCreateSnapshotResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RetryCreateSnapshot
// This API is used to retry to create snapshots and automatically fix vulnerabilities when the creation fails.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCEINUSE = "ResourceInUse"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) RetryCreateSnapshot(request *RetryCreateSnapshotRequest) (response *RetryCreateSnapshotResponse, err error) {
    return c.RetryCreateSnapshotWithContext(context.Background(), request)
}

// RetryCreateSnapshot
// This API is used to retry to create snapshots and automatically fix vulnerabilities when the creation fails.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCEINUSE = "ResourceInUse"
//  RESOURCEINSUFFICIENT = "ResourceInsufficient"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) RetryCreateSnapshotWithContext(ctx context.Context, request *RetryCreateSnapshotRequest) (response *RetryCreateSnapshotResponse, err error) {
    if request == nil {
        request = NewRetryCreateSnapshotRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RetryCreateSnapshot")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RetryCreateSnapshot require credential")
    }

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

func NewRetryVulFixRequest() (request *RetryVulFixRequest) {
    request = &RetryVulFixRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "RetryVulFix")
    
    
    return
}

func NewRetryVulFixResponse() (response *RetryVulFixResponse) {
    response = &RetryVulFixResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// RetryVulFix
// This API is used to fix vulnerabilities on a single host when the fix fails.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) RetryVulFix(request *RetryVulFixRequest) (response *RetryVulFixResponse, err error) {
    return c.RetryVulFixWithContext(context.Background(), request)
}

// RetryVulFix
// This API is used to fix vulnerabilities on a single host when the fix fails.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCEUNAVAILABLE = "ResourceUnavailable"
//  UNAUTHORIZEDOPERATION = "UnauthorizedOperation"
func (c *Client) RetryVulFixWithContext(ctx context.Context, request *RetryVulFixRequest) (response *RetryVulFixResponse, err error) {
    if request == nil {
        request = NewRetryVulFixRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "RetryVulFix")
    
    if c.GetCredential() == nil {
        return nil, errors.New("RetryVulFix require credential")
    }

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

func NewScanBaselineRequest() (request *ScanBaselineRequest) {
    request = &ScanBaselineRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ScanBaseline")
    
    
    return
}

func NewScanBaselineResponse() (response *ScanBaselineResponse) {
    response = &ScanBaselineResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ScanBaseline
// This API is used to obtain baseline detection and re-detection APIs.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
func (c *Client) ScanBaseline(request *ScanBaselineRequest) (response *ScanBaselineResponse, err error) {
    return c.ScanBaselineWithContext(context.Background(), request)
}

// ScanBaseline
// This API is used to obtain baseline detection and re-detection APIs.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
func (c *Client) ScanBaselineWithContext(ctx context.Context, request *ScanBaselineRequest) (response *ScanBaselineResponse, err error) {
    if request == nil {
        request = NewScanBaselineRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ScanBaseline")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ScanBaseline require credential")
    }

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

func NewScanTaskAgainRequest() (request *ScanTaskAgainRequest) {
    request = &ScanTaskAgainRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ScanTaskAgain")
    
    
    return
}

func NewScanTaskAgainResponse() (response *ScanTaskAgainResponse) {
    response = &ScanTaskAgainResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ScanTaskAgain
// This API is used to restart the scan task. Specifying the machine is supported.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
func (c *Client) ScanTaskAgain(request *ScanTaskAgainRequest) (response *ScanTaskAgainResponse, err error) {
    return c.ScanTaskAgainWithContext(context.Background(), request)
}

// ScanTaskAgain
// This API is used to restart the scan task. Specifying the machine is supported.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
//  RESOURCENOTFOUND_MACHINENOTFOUND = "ResourceNotFound.MachineNotFound"
func (c *Client) ScanTaskAgainWithContext(ctx context.Context, request *ScanTaskAgainRequest) (response *ScanTaskAgainResponse, err error) {
    if request == nil {
        request = NewScanTaskAgainRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ScanTaskAgain")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ScanTaskAgain require credential")
    }

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

func NewScanVulRequest() (request *ScanVulRequest) {
    request = &ScanVulRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ScanVul")
    
    
    return
}

func NewScanVulResponse() (response *ScanVulResponse) {
    response = &ScanVulResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ScanVul
// This API is used to perform one-click vulnerability scans.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ScanVul(request *ScanVulRequest) (response *ScanVulResponse, err error) {
    return c.ScanVulWithContext(context.Background(), request)
}

// ScanVul
// This API is used to perform one-click vulnerability scans.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ScanVulWithContext(ctx context.Context, request *ScanVulRequest) (response *ScanVulResponse, err error) {
    if request == nil {
        request = NewScanVulRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ScanVul")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ScanVul require credential")
    }

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

func NewScanVulAgainRequest() (request *ScanVulAgainRequest) {
    request = &ScanVulAgainRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ScanVulAgain")
    
    
    return
}

func NewScanVulAgainResponse() (response *ScanVulAgainResponse) {
    response = &ScanVulAgainResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ScanVulAgain
// This API is used to redetect the API.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_RESCANVUL = "FailedOperation.RescanVul"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ScanVulAgain(request *ScanVulAgainRequest) (response *ScanVulAgainResponse, err error) {
    return c.ScanVulAgainWithContext(context.Background(), request)
}

// ScanVulAgain
// This API is used to redetect the API.
//
// error code that may be returned:
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  FAILEDOPERATION_RESCANVUL = "FailedOperation.RescanVul"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  OPERATIONDENIED = "OperationDenied"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) ScanVulAgainWithContext(ctx context.Context, request *ScanVulAgainRequest) (response *ScanVulAgainResponse, err error) {
    if request == nil {
        request = NewScanVulAgainRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ScanVulAgain")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ScanVulAgain require credential")
    }

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

func NewScanVulSettingRequest() (request *ScanVulSettingRequest) {
    request = &ScanVulSettingRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "ScanVulSetting")
    
    
    return
}

func NewScanVulSettingResponse() (response *ScanVulSettingResponse) {
    response = &ScanVulSettingResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// ScanVulSetting
// This API is used to complete regular vulnerability scan settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ScanVulSetting(request *ScanVulSettingRequest) (response *ScanVulSettingResponse, err error) {
    return c.ScanVulSettingWithContext(context.Background(), request)
}

// ScanVulSetting
// This API is used to complete regular vulnerability scan settings.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) ScanVulSettingWithContext(ctx context.Context, request *ScanVulSettingRequest) (response *ScanVulSettingResponse, err error) {
    if request == nil {
        request = NewScanVulSettingRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "ScanVulSetting")
    
    if c.GetCredential() == nil {
        return nil, errors.New("ScanVulSetting require credential")
    }

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

func NewSearchLogRequest() (request *SearchLogRequest) {
    request = &SearchLogRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SearchLog")
    
    
    return
}

func NewSearchLogResponse() (response *SearchLogResponse) {
    response = &SearchLogResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SearchLog
// This API is used to query logs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SearchLog(request *SearchLogRequest) (response *SearchLogResponse, err error) {
    return c.SearchLogWithContext(context.Background(), request)
}

// SearchLog
// This API is used to query logs.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SearchLogWithContext(ctx context.Context, request *SearchLogRequest) (response *SearchLogResponse, err error) {
    if request == nil {
        request = NewSearchLogRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SearchLog")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SearchLog require credential")
    }

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

func NewSeparateMalwaresRequest() (request *SeparateMalwaresRequest) {
    request = &SeparateMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SeparateMalwares")
    
    
    return
}

func NewSeparateMalwaresResponse() (response *SeparateMalwaresResponse) {
    response = &SeparateMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SeparateMalwares
// This API is used to isolate Trojans.
//
// error code that may be returned:
//  FAILEDOPERATION_PARTSEPARATE = "FailedOperation.PartSeparate"
//  FAILEDOPERATION_SINGLESEPARATE = "FailedOperation.SingleSeparate"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SeparateMalwares(request *SeparateMalwaresRequest) (response *SeparateMalwaresResponse, err error) {
    return c.SeparateMalwaresWithContext(context.Background(), request)
}

// SeparateMalwares
// This API is used to isolate Trojans.
//
// error code that may be returned:
//  FAILEDOPERATION_PARTSEPARATE = "FailedOperation.PartSeparate"
//  FAILEDOPERATION_SINGLESEPARATE = "FailedOperation.SingleSeparate"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SeparateMalwaresWithContext(ctx context.Context, request *SeparateMalwaresRequest) (response *SeparateMalwaresResponse, err error) {
    if request == nil {
        request = NewSeparateMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SeparateMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SeparateMalwares require credential")
    }

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

func NewSetBashEventsStatusRequest() (request *SetBashEventsStatusRequest) {
    request = &SetBashEventsStatusRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SetBashEventsStatus")
    
    
    return
}

func NewSetBashEventsStatusResponse() (response *SetBashEventsStatusResponse) {
    response = &SetBashEventsStatusResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SetBashEventsStatus
// This API is used to set the high-risk command event status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SetBashEventsStatus(request *SetBashEventsStatusRequest) (response *SetBashEventsStatusResponse, err error) {
    return c.SetBashEventsStatusWithContext(context.Background(), request)
}

// SetBashEventsStatus
// This API is used to set the high-risk command event status.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SetBashEventsStatusWithContext(ctx context.Context, request *SetBashEventsStatusRequest) (response *SetBashEventsStatusResponse, err error) {
    if request == nil {
        request = NewSetBashEventsStatusRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SetBashEventsStatus")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SetBashEventsStatus require credential")
    }

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

func NewSetLocalStorageExpireRequest() (request *SetLocalStorageExpireRequest) {
    request = &SetLocalStorageExpireRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SetLocalStorageExpire")
    
    
    return
}

func NewSetLocalStorageExpireResponse() (response *SetLocalStorageExpireResponse) {
    response = &SetLocalStorageExpireResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SetLocalStorageExpire
// This API is used to set the expiration time of the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) SetLocalStorageExpire(request *SetLocalStorageExpireRequest) (response *SetLocalStorageExpireResponse, err error) {
    return c.SetLocalStorageExpireWithContext(context.Background(), request)
}

// SetLocalStorageExpire
// This API is used to set the expiration time of the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) SetLocalStorageExpireWithContext(ctx context.Context, request *SetLocalStorageExpireRequest) (response *SetLocalStorageExpireResponse, err error) {
    if request == nil {
        request = NewSetLocalStorageExpireRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SetLocalStorageExpire")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SetLocalStorageExpire require credential")
    }

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

func NewSetLocalStorageItemRequest() (request *SetLocalStorageItemRequest) {
    request = &SetLocalStorageItemRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SetLocalStorageItem")
    
    
    return
}

func NewSetLocalStorageItemResponse() (response *SetLocalStorageItemResponse) {
    response = &SetLocalStorageItemResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SetLocalStorageItem
// This API is used to set the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) SetLocalStorageItem(request *SetLocalStorageItemRequest) (response *SetLocalStorageItemResponse, err error) {
    return c.SetLocalStorageItemWithContext(context.Background(), request)
}

// SetLocalStorageItem
// This API is used to set the locally stored data.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) SetLocalStorageItemWithContext(ctx context.Context, request *SetLocalStorageItemRequest) (response *SetLocalStorageItemResponse, err error) {
    if request == nil {
        request = NewSetLocalStorageItemRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SetLocalStorageItem")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SetLocalStorageItem require credential")
    }

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

func NewStartBaselineDetectRequest() (request *StartBaselineDetectRequest) {
    request = &StartBaselineDetectRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "StartBaselineDetect")
    
    
    return
}

func NewStartBaselineDetectResponse() (response *StartBaselineDetectResponse) {
    response = &StartBaselineDetectResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// StartBaselineDetect
// This API is used to perform baseline checks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) StartBaselineDetect(request *StartBaselineDetectRequest) (response *StartBaselineDetectResponse, err error) {
    return c.StartBaselineDetectWithContext(context.Background(), request)
}

// StartBaselineDetect
// This API is used to perform baseline checks.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  OPERATIONDENIED = "OperationDenied"
func (c *Client) StartBaselineDetectWithContext(ctx context.Context, request *StartBaselineDetectRequest) (response *StartBaselineDetectResponse, err error) {
    if request == nil {
        request = NewStartBaselineDetectRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "StartBaselineDetect")
    
    if c.GetCredential() == nil {
        return nil, errors.New("StartBaselineDetect require credential")
    }

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

func NewStopAssetScanRequest() (request *StopAssetScanRequest) {
    request = &StopAssetScanRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "StopAssetScan")
    
    
    return
}

func NewStopAssetScanResponse() (response *StopAssetScanResponse) {
    response = &StopAssetScanResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// StopAssetScan
// This API is used to stop the asset scan task.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) StopAssetScan(request *StopAssetScanRequest) (response *StopAssetScanResponse, err error) {
    return c.StopAssetScanWithContext(context.Background(), request)
}

// StopAssetScan
// This API is used to stop the asset scan task.
//
// error code that may be returned:
//  AUTHFAILURE = "AuthFailure"
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
func (c *Client) StopAssetScanWithContext(ctx context.Context, request *StopAssetScanRequest) (response *StopAssetScanResponse, err error) {
    if request == nil {
        request = NewStopAssetScanRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "StopAssetScan")
    
    if c.GetCredential() == nil {
        return nil, errors.New("StopAssetScan require credential")
    }

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

func NewStopBaselineDetectRequest() (request *StopBaselineDetectRequest) {
    request = &StopBaselineDetectRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "StopBaselineDetect")
    
    
    return
}

func NewStopBaselineDetectResponse() (response *StopBaselineDetectResponse) {
    response = &StopBaselineDetectResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// StopBaselineDetect
// This API is used to stop baseline check.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) StopBaselineDetect(request *StopBaselineDetectRequest) (response *StopBaselineDetectResponse, err error) {
    return c.StopBaselineDetectWithContext(context.Background(), request)
}

// StopBaselineDetect
// This API is used to stop baseline check.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) StopBaselineDetectWithContext(ctx context.Context, request *StopBaselineDetectRequest) (response *StopBaselineDetectResponse, err error) {
    if request == nil {
        request = NewStopBaselineDetectRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "StopBaselineDetect")
    
    if c.GetCredential() == nil {
        return nil, errors.New("StopBaselineDetect require credential")
    }

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

func NewStopNoticeBanTipsRequest() (request *StopNoticeBanTipsRequest) {
    request = &StopNoticeBanTipsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "StopNoticeBanTips")
    
    
    return
}

func NewStopNoticeBanTipsResponse() (response *StopNoticeBanTipsResponse) {
    response = &StopNoticeBanTipsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// StopNoticeBanTips
// This API is used to stop displaying pop-up prompts about brute force cracking blocking.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) StopNoticeBanTips(request *StopNoticeBanTipsRequest) (response *StopNoticeBanTipsResponse, err error) {
    return c.StopNoticeBanTipsWithContext(context.Background(), request)
}

// StopNoticeBanTips
// This API is used to stop displaying pop-up prompts about brute force cracking blocking.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
func (c *Client) StopNoticeBanTipsWithContext(ctx context.Context, request *StopNoticeBanTipsRequest) (response *StopNoticeBanTipsResponse, err error) {
    if request == nil {
        request = NewStopNoticeBanTipsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "StopNoticeBanTips")
    
    if c.GetCredential() == nil {
        return nil, errors.New("StopNoticeBanTips require credential")
    }

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

func NewSwitchBashRulesRequest() (request *SwitchBashRulesRequest) {
    request = &SwitchBashRulesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SwitchBashRules")
    
    
    return
}

func NewSwitchBashRulesResponse() (response *SwitchBashRulesResponse) {
    response = &SwitchBashRulesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SwitchBashRules
// This API is used to switch the statuses of high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SwitchBashRules(request *SwitchBashRulesRequest) (response *SwitchBashRulesResponse, err error) {
    return c.SwitchBashRulesWithContext(context.Background(), request)
}

// SwitchBashRules
// This API is used to switch the statuses of high-risk command rules.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_DATERANGE = "InvalidParameter.DateRange"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETER_REGEXRULEERROR = "InvalidParameter.RegexRuleError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SwitchBashRulesWithContext(ctx context.Context, request *SwitchBashRulesRequest) (response *SwitchBashRulesResponse, err error) {
    if request == nil {
        request = NewSwitchBashRulesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SwitchBashRules")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SwitchBashRules require credential")
    }

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

func NewSyncAssetScanRequest() (request *SyncAssetScanRequest) {
    request = &SyncAssetScanRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SyncAssetScan")
    
    
    return
}

func NewSyncAssetScanResponse() (response *SyncAssetScanResponse) {
    response = &SyncAssetScanResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SyncAssetScan
// This API is used to synchronize the asset scan information.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SyncAssetScan(request *SyncAssetScanRequest) (response *SyncAssetScanResponse, err error) {
    return c.SyncAssetScanWithContext(context.Background(), request)
}

// SyncAssetScan
// This API is used to synchronize the asset scan information.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INTERNALERROR_MAINDBFAIL = "InternalError.MainDBFail"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) SyncAssetScanWithContext(ctx context.Context, request *SyncAssetScanRequest) (response *SyncAssetScanResponse, err error) {
    if request == nil {
        request = NewSyncAssetScanRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SyncAssetScan")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SyncAssetScan require credential")
    }

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

func NewSyncBaselineDetectSummaryRequest() (request *SyncBaselineDetectSummaryRequest) {
    request = &SyncBaselineDetectSummaryRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SyncBaselineDetectSummary")
    
    
    return
}

func NewSyncBaselineDetectSummaryResponse() (response *SyncBaselineDetectSummaryResponse) {
    response = &SyncBaselineDetectSummaryResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SyncBaselineDetectSummary
// This API is used to sync the summary of baseline detection progress.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) SyncBaselineDetectSummary(request *SyncBaselineDetectSummaryRequest) (response *SyncBaselineDetectSummaryResponse, err error) {
    return c.SyncBaselineDetectSummaryWithContext(context.Background(), request)
}

// SyncBaselineDetectSummary
// This API is used to sync the summary of baseline detection progress.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
func (c *Client) SyncBaselineDetectSummaryWithContext(ctx context.Context, request *SyncBaselineDetectSummaryRequest) (response *SyncBaselineDetectSummaryResponse, err error) {
    if request == nil {
        request = NewSyncBaselineDetectSummaryRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SyncBaselineDetectSummary")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SyncBaselineDetectSummary require credential")
    }

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

func NewSyncMachinesRequest() (request *SyncMachinesRequest) {
    request = &SyncMachinesRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "SyncMachines")
    
    
    return
}

func NewSyncMachinesResponse() (response *SyncMachinesResponse) {
    response = &SyncMachinesResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// SyncMachines
// This API is used to sync the machine information.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SyncMachines(request *SyncMachinesRequest) (response *SyncMachinesResponse, err error) {
    return c.SyncMachinesWithContext(context.Background(), request)
}

// SyncMachines
// This API is used to sync the machine information.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  FAILEDOPERATION_APISERVERFAIL = "FailedOperation.APIServerFail"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) SyncMachinesWithContext(ctx context.Context, request *SyncMachinesRequest) (response *SyncMachinesResponse, err error) {
    if request == nil {
        request = NewSyncMachinesRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "SyncMachines")
    
    if c.GetCredential() == nil {
        return nil, errors.New("SyncMachines require credential")
    }

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

func NewTestWebHookRuleRequest() (request *TestWebHookRuleRequest) {
    request = &TestWebHookRuleRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "TestWebHookRule")
    
    
    return
}

func NewTestWebHookRuleResponse() (response *TestWebHookRuleResponse) {
    response = &TestWebHookRuleResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// TestWebHookRule
// This API is used to test the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) TestWebHookRule(request *TestWebHookRuleRequest) (response *TestWebHookRuleResponse, err error) {
    return c.TestWebHookRuleWithContext(context.Background(), request)
}

// TestWebHookRule
// This API is used to test the rules of WeCom chatbots.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
func (c *Client) TestWebHookRuleWithContext(ctx context.Context, request *TestWebHookRuleRequest) (response *TestWebHookRuleResponse, err error) {
    if request == nil {
        request = NewTestWebHookRuleRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "TestWebHookRule")
    
    if c.GetCredential() == nil {
        return nil, errors.New("TestWebHookRule require credential")
    }

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

func NewTrustMalwaresRequest() (request *TrustMalwaresRequest) {
    request = &TrustMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "TrustMalwares")
    
    
    return
}

func NewTrustMalwaresResponse() (response *TrustMalwaresResponse) {
    response = &TrustMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// TrustMalwares
// This API is used to mark identified Trojan files as Trusted.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) TrustMalwares(request *TrustMalwaresRequest) (response *TrustMalwaresResponse, err error) {
    return c.TrustMalwaresWithContext(context.Background(), request)
}

// TrustMalwares
// This API is used to mark identified Trojan files as Trusted.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  LIMITEXCEEDED_AREAQUOTA = "LimitExceeded.AreaQuota"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) TrustMalwaresWithContext(ctx context.Context, request *TrustMalwaresRequest) (response *TrustMalwaresResponse, err error) {
    if request == nil {
        request = NewTrustMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "TrustMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("TrustMalwares require credential")
    }

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

func NewUntrustMalwaresRequest() (request *UntrustMalwaresRequest) {
    request = &UntrustMalwaresRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "UntrustMalwares")
    
    
    return
}

func NewUntrustMalwaresResponse() (response *UntrustMalwaresResponse) {
    response = &UntrustMalwaresResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UntrustMalwares
// This API is used to untrust Trojan files.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) UntrustMalwares(request *UntrustMalwaresRequest) (response *UntrustMalwaresResponse, err error) {
    return c.UntrustMalwaresWithContext(context.Background(), request)
}

// UntrustMalwares
// This API is used to untrust Trojan files.
//
// error code that may be returned:
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_INVALIDFORMAT = "InvalidParameter.InvalidFormat"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) UntrustMalwaresWithContext(ctx context.Context, request *UntrustMalwaresRequest) (response *UntrustMalwaresResponse, err error) {
    if request == nil {
        request = NewUntrustMalwaresRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "UntrustMalwares")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UntrustMalwares require credential")
    }

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

func NewUpdateBaselineStrategyRequest() (request *UpdateBaselineStrategyRequest) {
    request = &UpdateBaselineStrategyRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "UpdateBaselineStrategy")
    
    
    return
}

func NewUpdateBaselineStrategyResponse() (response *UpdateBaselineStrategyResponse) {
    response = &UpdateBaselineStrategyResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UpdateBaselineStrategy
// This API is used to update the policy information based on baseline policy IDs.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) UpdateBaselineStrategy(request *UpdateBaselineStrategyRequest) (response *UpdateBaselineStrategyResponse, err error) {
    return c.UpdateBaselineStrategyWithContext(context.Background(), request)
}

// UpdateBaselineStrategy
// This API is used to update the policy information based on baseline policy IDs.
//
// error code that may be returned:
//  FAILEDOPERATION_NOPROFESSIONHOST = "FailedOperation.NoProfessionHost"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_ILLEGALREQUEST = "InvalidParameter.IllegalRequest"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  MISSINGPARAMETER = "MissingParameter"
func (c *Client) UpdateBaselineStrategyWithContext(ctx context.Context, request *UpdateBaselineStrategyRequest) (response *UpdateBaselineStrategyResponse, err error) {
    if request == nil {
        request = NewUpdateBaselineStrategyRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "UpdateBaselineStrategy")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UpdateBaselineStrategy require credential")
    }

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

func NewUpdateMachineTagsRequest() (request *UpdateMachineTagsRequest) {
    request = &UpdateMachineTagsRequest{
        BaseRequest: &tchttp.BaseRequest{},
    }
    
    request.Init().WithApiInfo("cwp", APIVersion, "UpdateMachineTags")
    
    
    return
}

func NewUpdateMachineTagsResponse() (response *UpdateMachineTagsResponse) {
    response = &UpdateMachineTagsResponse{
        BaseResponse: &tchttp.BaseResponse{},
    } 
    return

}

// UpdateMachineTags
// This API is used to obtain the list of tags associated with machines.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) UpdateMachineTags(request *UpdateMachineTagsRequest) (response *UpdateMachineTagsResponse, err error) {
    return c.UpdateMachineTagsWithContext(context.Background(), request)
}

// UpdateMachineTags
// This API is used to obtain the list of tags associated with machines.
//
// error code that may be returned:
//  FAILEDOPERATION = "FailedOperation"
//  INTERNALERROR = "InternalError"
//  INVALIDPARAMETER = "InvalidParameter"
//  INVALIDPARAMETER_MISSINGPARAMETER = "InvalidParameter.MissingParameter"
//  INVALIDPARAMETER_PARSINGERROR = "InvalidParameter.ParsingError"
//  INVALIDPARAMETERVALUE = "InvalidParameterValue"
//  RESOURCENOTFOUND = "ResourceNotFound"
func (c *Client) UpdateMachineTagsWithContext(ctx context.Context, request *UpdateMachineTagsRequest) (response *UpdateMachineTagsResponse, err error) {
    if request == nil {
        request = NewUpdateMachineTagsRequest()
    }
    c.InitBaseRequest(&request.BaseRequest, "cwp", APIVersion, "UpdateMachineTags")
    
    if c.GetCredential() == nil {
        return nil, errors.New("UpdateMachineTags require credential")
    }

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