func (cli *Client) GetTrafficLimit(domain string) (*api.TrafficLimit, error) {
	return api.GetTrafficLimit(cli, domain)
}
GetTrafficLimit - get the traffic limitation of the specified domain
For details, please refer https://cloud.baidu.com/doc/CDN/s/7k4npdru0

PARAMS:
- domain: the specified domain
RETURNS:
- *TrafficLimit: config of traffic limitation
- error: nil if success otherwise the specific error
package cdn
import (
	"github.com/baidubce/bce-sdk-go/auth"
	"github.com/baidubce/bce-sdk-go/bce"
	"github.com/baidubce/bce-sdk-go/services/cdn/api"
)
const (
	DEFAULT_SERVICE_DOMAIN = "cdn.baidubce.com"
)
type Client struct {
	*bce.BceClient
}
func NewClient(ak, sk, endpoint string) (*Client, error) {
	var credentials *auth.BceCredentials
	var err error
	if len(ak) == 0 && len(sk) == 0 {  
		credentials, err = nil, nil
	} else {
		credentials, err = auth.NewBceCredentials(ak, sk)
		if err != nil {
			return nil, err
		}
	}
	if len(endpoint) == 0 {
		endpoint = DEFAULT_SERVICE_DOMAIN
	}
	defaultSignOptions := &auth.SignOptions{
		HeadersToSign: auth.DEFAULT_HEADERS_TO_SIGN,
		ExpireSeconds: auth.DEFAULT_EXPIRE_SECONDS}
	defaultConf := &bce.BceClientConfiguration{
		Endpoint:                  endpoint,
		Region:                    bce.DEFAULT_REGION,
		UserAgent:                 bce.DEFAULT_USER_AGENT,
		Credentials:               credentials,
		SignOption:                defaultSignOptions,
		Retry:                     bce.DEFAULT_RETRY_POLICY,
		ConnectionTimeoutInMillis: bce.DEFAULT_CONNECTION_TIMEOUT_IN_MILLIS}
	v1Signer := &auth.BceV1Signer{}
	client := &Client{bce.NewBceClient(defaultConf, v1Signer)}
	return client, nil
}
func (cli *Client) SendCustomRequest(method string, urlPath string, params, reqHeaders map[string]string, bodyObj interface{}, respObj interface{}) error {
	return api.SendCustomRequest(cli, method, urlPath, params, reqHeaders, bodyObj, respObj)
}
func (cli *Client) ListDomains(marker string) ([]string, string, error) {
	return api.ListDomains(cli, marker)
}
func (cli *Client) GetDomainStatus(status string, rule string) ([]api.DomainStatus, error) {
	return api.GetDomainStatus(cli, status, rule)
}
func (cli *Client) IsValidDomain(domain string) (*api.DomainValidInfo, error) {
	return api.IsValidDomain(cli, domain)
}
func (cli *Client) CreateDomain(domain string, originInit *api.OriginInit) (*api.DomainCreatedInfo, error) {
	return api.CreateDomain(cli, domain, originInit)
}
func (cli *Client) EnableDomain(domain string) error {
	return api.EnableDomain(cli, domain)
}
func (cli *Client) DisableDomain(domain string) error {
	return api.DisableDomain(cli, domain)
}
func (cli *Client) DeleteDomain(domain string) error {
	return api.DeleteDomain(cli, domain)
}
func (cli *Client) GetIpInfo(ip string, action string) (*api.IpInfo, error) {
	return api.GetIpInfo(cli, ip, action)
}
func (cli *Client) GetIpListInfo(ips []string, action string) ([]api.IpInfo, error) {
	return api.GetIpListInfo(cli, ips, action)
}
func (cli *Client) GetBackOriginNodes() ([]api.BackOriginNode, error) {
	return api.GetBackOriginNodes(cli)
}
func (cli *Client) GetDomainConfig(domain string) (*api.DomainConfig, error) {
	return api.GetDomainConfig(cli, domain)
}
func (cli *Client) SetDomainOrigin(domain string, origins []api.OriginPeer, defaultHost string) error {
	return api.SetDomainOrigin(cli, domain, origins, defaultHost)
}
func (cli *Client) SetOriginProtocol(domain string, originProtocol string) error {
	return api.SetOriginProtocol(cli, domain, originProtocol)
}
func (cli *Client) GetOriginProtocol(domain string) (string, error) {
	return api.GetOriginProtocol(cli, domain)
}
func (cli *Client) SetDomainSeo(domain string, seoSwitch *api.SeoSwitch) error {
	return api.SetDomainSeo(cli, domain, seoSwitch)
}
func (cli *Client) GetDomainSeo(domain string) (*api.SeoSwitch, error) {
	return api.GetDomainSeo(cli, domain)
}
func (cli *Client) GetCacheTTL(domain string) ([]api.CacheTTL, error) {
	return api.GetCacheTTL(cli, domain)
}
func (cli *Client) SetCacheTTL(domain string, cacheTTLs []api.CacheTTL) error {
	return api.SetCacheTTL(cli, domain, cacheTTLs)
}
func (cli *Client) SetRefererACL(domain string, blackList []string, whiteList []string, isAllowEmpty bool) error {
	return api.SetRefererACL(cli, domain, blackList, whiteList, isAllowEmpty)
}
func (cli *Client) GetRefererACL(domain string) (*api.RefererACL, error) {
	return api.GetRefererACL(cli, domain)
}
func (cli *Client) SetIpACL(domain string, blackList []string, whiteList []string) error {
	return api.SetIpACL(cli, domain, blackList, whiteList)
}
func (cli *Client) GetIpACL(domain string) (*api.IpACL, error) {
	return api.GetIpACL(cli, domain)
}
func (cli *Client) SetUaACL(domain string, blackList []string, whiteList []string) error {
	return api.SetUaACL(cli, domain, blackList, whiteList)
}
func (cli *Client) GetUaACL(domain string) (*api.UaACL, error) {
	return api.GetUaACL(cli, domain)
}
func (cli *Client) SetLimitRate(domain string, limitRate int) error {
	return api.SetLimitRate(cli, domain, limitRate)
}
func (cli *Client) SetTrafficLimit(domain string, trafficLimit *api.TrafficLimit) error {
	return api.SetTrafficLimit(cli, domain, trafficLimit)
}