modifiedclient.go raw
1 // This file is auto-generated, don't edit it. Thanks.
2 package client
3
4 import (
5 openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
6 openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
7 "github.com/alibabacloud-go/tea/dara"
8 )
9
10 type Client struct {
11 openapi.Client
12 DisableSDKError *bool
13 EnableValidate *bool
14 }
15
16 func NewClient(config *openapiutil.Config) (*Client, error) {
17 client := new(Client)
18 err := client.Init(config)
19 return client, err
20 }
21
22 func (client *Client) Init(config *openapiutil.Config) (_err error) {
23 _err = client.Client.Init(config)
24 if _err != nil {
25 return _err
26 }
27 client.EndpointRule = dara.String("central")
28 _err = client.CheckConfig(config)
29 if _err != nil {
30 return _err
31 }
32 client.Endpoint, _err = GetEndpoint(client,dara.String("alidns"), client.RegionId, client.EndpointRule, client.Network, client.Suffix, client.EndpointMap, client.Endpoint)
33 if _err != nil {
34 return _err
35 }
36
37 return nil
38 }
39
40 func GetEndpoint(client *Client, productId *string, regionId *string, endpointRule *string, network *string, suffix *string, endpointMap map[string]*string, endpoint *string) (_result *string, _err error) {
41 if !dara.IsNil(endpoint) {
42 _result = endpoint
43 return _result, _err
44 }
45
46 if !dara.IsNil(endpointMap) && !dara.IsNil(endpointMap[dara.StringValue(regionId)]) {
47 _result = endpointMap[dara.StringValue(regionId)]
48 return _result, _err
49 }
50
51 _body, _err := openapiutil.GetEndpointRules(productId, regionId, endpointRule, network, suffix)
52 if _err != nil {
53 return _result, _err
54 }
55 _result = _body
56 return _result, _err
57 }
58
59 // Summary:
60 //
61 // Adds a custom line to the domain name.
62 //
63 // Description:
64 //
65 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
66 //
67 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
68 //
69 // @param request - AddCustomLineRequest
70 //
71 // @param runtime - runtime options for this request RuntimeOptions
72 //
73 // @return AddCustomLineResponse
74 func AddCustomLineWithOptions(client *Client, request *AddCustomLineRequest, runtime *dara.RuntimeOptions) (_result *AddCustomLineResponse, _err error) {
75 if dara.BoolValue(client.EnableValidate) == true {
76 _err = request.Validate()
77 if _err != nil {
78 return _result, _err
79 }
80 }
81 query := map[string]interface{}{}
82 if !dara.IsNil(request.DomainName) {
83 query["DomainName"] = request.DomainName
84 }
85
86 if !dara.IsNil(request.IpSegment) {
87 query["IpSegment"] = request.IpSegment
88 }
89
90 if !dara.IsNil(request.Lang) {
91 query["Lang"] = request.Lang
92 }
93
94 if !dara.IsNil(request.LineName) {
95 query["LineName"] = request.LineName
96 }
97
98 req := &openapiutil.OpenApiRequest{
99 Query: openapiutil.Query(query),
100 }
101 params := &openapiutil.Params{
102 Action: dara.String("AddCustomLine"),
103 Version: dara.String("2015-01-09"),
104 Protocol: dara.String("HTTPS"),
105 Pathname: dara.String("/"),
106 Method: dara.String("POST"),
107 AuthType: dara.String("AK"),
108 Style: dara.String("RPC"),
109 ReqBodyType: dara.String("formData"),
110 BodyType: dara.String("json"),
111 }
112 _result = &AddCustomLineResponse{}
113 _body, _err := client.CallApi(params, req, runtime)
114 if _err != nil {
115 return _result, _err
116 }
117 _err = dara.Convert(_body, &_result)
118 return _result, _err
119 }
120
121 // Summary:
122 //
123 // Adds a custom line to the domain name.
124 //
125 // Description:
126 //
127 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
128 //
129 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
130 //
131 // @param request - AddCustomLineRequest
132 //
133 // @return AddCustomLineResponse
134 func AddCustomLine(client *Client, request *AddCustomLineRequest) (_result *AddCustomLineResponse, _err error) {
135 runtime := &dara.RuntimeOptions{}
136 _result = &AddCustomLineResponse{}
137 _body, _err := AddCustomLineWithOptions(client,request, runtime)
138 if _err != nil {
139 return _result, _err
140 }
141 _result = _body
142 return _result, _err
143 }
144
145 // Summary:
146 //
147 // Adds a cache-accelerated domain name based on the specified parameters.
148 //
149 // @param request - AddDnsCacheDomainRequest
150 //
151 // @param runtime - runtime options for this request RuntimeOptions
152 //
153 // @return AddDnsCacheDomainResponse
154 func AddDnsCacheDomainWithOptions(client *Client, request *AddDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *AddDnsCacheDomainResponse, _err error) {
155 if dara.BoolValue(client.EnableValidate) == true {
156 _err = request.Validate()
157 if _err != nil {
158 return _result, _err
159 }
160 }
161 query := map[string]interface{}{}
162 if !dara.IsNil(request.CacheTtlMax) {
163 query["CacheTtlMax"] = request.CacheTtlMax
164 }
165
166 if !dara.IsNil(request.CacheTtlMin) {
167 query["CacheTtlMin"] = request.CacheTtlMin
168 }
169
170 if !dara.IsNil(request.DomainName) {
171 query["DomainName"] = request.DomainName
172 }
173
174 if !dara.IsNil(request.InstanceId) {
175 query["InstanceId"] = request.InstanceId
176 }
177
178 if !dara.IsNil(request.Lang) {
179 query["Lang"] = request.Lang
180 }
181
182 if !dara.IsNil(request.Remark) {
183 query["Remark"] = request.Remark
184 }
185
186 if !dara.IsNil(request.SourceDnsServer) {
187 query["SourceDnsServer"] = request.SourceDnsServer
188 }
189
190 if !dara.IsNil(request.SourceEdns) {
191 query["SourceEdns"] = request.SourceEdns
192 }
193
194 if !dara.IsNil(request.SourceProtocol) {
195 query["SourceProtocol"] = request.SourceProtocol
196 }
197
198 req := &openapiutil.OpenApiRequest{
199 Query: openapiutil.Query(query),
200 }
201 params := &openapiutil.Params{
202 Action: dara.String("AddDnsCacheDomain"),
203 Version: dara.String("2015-01-09"),
204 Protocol: dara.String("HTTPS"),
205 Pathname: dara.String("/"),
206 Method: dara.String("POST"),
207 AuthType: dara.String("AK"),
208 Style: dara.String("RPC"),
209 ReqBodyType: dara.String("formData"),
210 BodyType: dara.String("json"),
211 }
212 _result = &AddDnsCacheDomainResponse{}
213 _body, _err := client.CallApi(params, req, runtime)
214 if _err != nil {
215 return _result, _err
216 }
217 _err = dara.Convert(_body, &_result)
218 return _result, _err
219 }
220
221 // Summary:
222 //
223 // Adds a cache-accelerated domain name based on the specified parameters.
224 //
225 // @param request - AddDnsCacheDomainRequest
226 //
227 // @return AddDnsCacheDomainResponse
228 func AddDnsCacheDomain(client *Client, request *AddDnsCacheDomainRequest) (_result *AddDnsCacheDomainResponse, _err error) {
229 runtime := &dara.RuntimeOptions{}
230 _result = &AddDnsCacheDomainResponse{}
231 _body, _err := AddDnsCacheDomainWithOptions(client,request, runtime)
232 if _err != nil {
233 return _result, _err
234 }
235 _result = _body
236 return _result, _err
237 }
238
239 // Summary:
240 //
241 // Creates an access policy.
242 //
243 // @param request - AddDnsGtmAccessStrategyRequest
244 //
245 // @param runtime - runtime options for this request RuntimeOptions
246 //
247 // @return AddDnsGtmAccessStrategyResponse
248 func AddDnsGtmAccessStrategyWithOptions(client *Client, request *AddDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmAccessStrategyResponse, _err error) {
249 if dara.BoolValue(client.EnableValidate) == true {
250 _err = request.Validate()
251 if _err != nil {
252 return _result, _err
253 }
254 }
255 query := map[string]interface{}{}
256 if !dara.IsNil(request.DefaultAddrPool) {
257 query["DefaultAddrPool"] = request.DefaultAddrPool
258 }
259
260 if !dara.IsNil(request.DefaultAddrPoolType) {
261 query["DefaultAddrPoolType"] = request.DefaultAddrPoolType
262 }
263
264 if !dara.IsNil(request.DefaultLatencyOptimization) {
265 query["DefaultLatencyOptimization"] = request.DefaultLatencyOptimization
266 }
267
268 if !dara.IsNil(request.DefaultLbaStrategy) {
269 query["DefaultLbaStrategy"] = request.DefaultLbaStrategy
270 }
271
272 if !dara.IsNil(request.DefaultMaxReturnAddrNum) {
273 query["DefaultMaxReturnAddrNum"] = request.DefaultMaxReturnAddrNum
274 }
275
276 if !dara.IsNil(request.DefaultMinAvailableAddrNum) {
277 query["DefaultMinAvailableAddrNum"] = request.DefaultMinAvailableAddrNum
278 }
279
280 if !dara.IsNil(request.FailoverAddrPool) {
281 query["FailoverAddrPool"] = request.FailoverAddrPool
282 }
283
284 if !dara.IsNil(request.FailoverAddrPoolType) {
285 query["FailoverAddrPoolType"] = request.FailoverAddrPoolType
286 }
287
288 if !dara.IsNil(request.FailoverLatencyOptimization) {
289 query["FailoverLatencyOptimization"] = request.FailoverLatencyOptimization
290 }
291
292 if !dara.IsNil(request.FailoverLbaStrategy) {
293 query["FailoverLbaStrategy"] = request.FailoverLbaStrategy
294 }
295
296 if !dara.IsNil(request.FailoverMaxReturnAddrNum) {
297 query["FailoverMaxReturnAddrNum"] = request.FailoverMaxReturnAddrNum
298 }
299
300 if !dara.IsNil(request.FailoverMinAvailableAddrNum) {
301 query["FailoverMinAvailableAddrNum"] = request.FailoverMinAvailableAddrNum
302 }
303
304 if !dara.IsNil(request.InstanceId) {
305 query["InstanceId"] = request.InstanceId
306 }
307
308 if !dara.IsNil(request.Lang) {
309 query["Lang"] = request.Lang
310 }
311
312 if !dara.IsNil(request.Lines) {
313 query["Lines"] = request.Lines
314 }
315
316 if !dara.IsNil(request.StrategyMode) {
317 query["StrategyMode"] = request.StrategyMode
318 }
319
320 if !dara.IsNil(request.StrategyName) {
321 query["StrategyName"] = request.StrategyName
322 }
323
324 req := &openapiutil.OpenApiRequest{
325 Query: openapiutil.Query(query),
326 }
327 params := &openapiutil.Params{
328 Action: dara.String("AddDnsGtmAccessStrategy"),
329 Version: dara.String("2015-01-09"),
330 Protocol: dara.String("HTTPS"),
331 Pathname: dara.String("/"),
332 Method: dara.String("POST"),
333 AuthType: dara.String("AK"),
334 Style: dara.String("RPC"),
335 ReqBodyType: dara.String("formData"),
336 BodyType: dara.String("json"),
337 }
338 _result = &AddDnsGtmAccessStrategyResponse{}
339 _body, _err := client.CallApi(params, req, runtime)
340 if _err != nil {
341 return _result, _err
342 }
343 _err = dara.Convert(_body, &_result)
344 return _result, _err
345 }
346
347 // Summary:
348 //
349 // Creates an access policy.
350 //
351 // @param request - AddDnsGtmAccessStrategyRequest
352 //
353 // @return AddDnsGtmAccessStrategyResponse
354 func AddDnsGtmAccessStrategy(client *Client, request *AddDnsGtmAccessStrategyRequest) (_result *AddDnsGtmAccessStrategyResponse, _err error) {
355 runtime := &dara.RuntimeOptions{}
356 _result = &AddDnsGtmAccessStrategyResponse{}
357 _body, _err := AddDnsGtmAccessStrategyWithOptions(client,request, runtime)
358 if _err != nil {
359 return _result, _err
360 }
361 _result = _body
362 return _result, _err
363 }
364
365 // Summary:
366 //
367 // Creates an address pool.
368 //
369 // @param request - AddDnsGtmAddressPoolRequest
370 //
371 // @param runtime - runtime options for this request RuntimeOptions
372 //
373 // @return AddDnsGtmAddressPoolResponse
374 func AddDnsGtmAddressPoolWithOptions(client *Client, request *AddDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmAddressPoolResponse, _err error) {
375 if dara.BoolValue(client.EnableValidate) == true {
376 _err = request.Validate()
377 if _err != nil {
378 return _result, _err
379 }
380 }
381 query := map[string]interface{}{}
382 if !dara.IsNil(request.Addr) {
383 query["Addr"] = request.Addr
384 }
385
386 if !dara.IsNil(request.EvaluationCount) {
387 query["EvaluationCount"] = request.EvaluationCount
388 }
389
390 if !dara.IsNil(request.InstanceId) {
391 query["InstanceId"] = request.InstanceId
392 }
393
394 if !dara.IsNil(request.Interval) {
395 query["Interval"] = request.Interval
396 }
397
398 if !dara.IsNil(request.IspCityNode) {
399 query["IspCityNode"] = request.IspCityNode
400 }
401
402 if !dara.IsNil(request.Lang) {
403 query["Lang"] = request.Lang
404 }
405
406 if !dara.IsNil(request.LbaStrategy) {
407 query["LbaStrategy"] = request.LbaStrategy
408 }
409
410 if !dara.IsNil(request.MonitorExtendInfo) {
411 query["MonitorExtendInfo"] = request.MonitorExtendInfo
412 }
413
414 if !dara.IsNil(request.MonitorStatus) {
415 query["MonitorStatus"] = request.MonitorStatus
416 }
417
418 if !dara.IsNil(request.Name) {
419 query["Name"] = request.Name
420 }
421
422 if !dara.IsNil(request.ProtocolType) {
423 query["ProtocolType"] = request.ProtocolType
424 }
425
426 if !dara.IsNil(request.Timeout) {
427 query["Timeout"] = request.Timeout
428 }
429
430 if !dara.IsNil(request.Type) {
431 query["Type"] = request.Type
432 }
433
434 req := &openapiutil.OpenApiRequest{
435 Query: openapiutil.Query(query),
436 }
437 params := &openapiutil.Params{
438 Action: dara.String("AddDnsGtmAddressPool"),
439 Version: dara.String("2015-01-09"),
440 Protocol: dara.String("HTTPS"),
441 Pathname: dara.String("/"),
442 Method: dara.String("POST"),
443 AuthType: dara.String("AK"),
444 Style: dara.String("RPC"),
445 ReqBodyType: dara.String("formData"),
446 BodyType: dara.String("json"),
447 }
448 _result = &AddDnsGtmAddressPoolResponse{}
449 _body, _err := client.CallApi(params, req, runtime)
450 if _err != nil {
451 return _result, _err
452 }
453 _err = dara.Convert(_body, &_result)
454 return _result, _err
455 }
456
457 // Summary:
458 //
459 // Creates an address pool.
460 //
461 // @param request - AddDnsGtmAddressPoolRequest
462 //
463 // @return AddDnsGtmAddressPoolResponse
464 func AddDnsGtmAddressPool(client *Client, request *AddDnsGtmAddressPoolRequest) (_result *AddDnsGtmAddressPoolResponse, _err error) {
465 runtime := &dara.RuntimeOptions{}
466 _result = &AddDnsGtmAddressPoolResponse{}
467 _body, _err := AddDnsGtmAddressPoolWithOptions(client,request, runtime)
468 if _err != nil {
469 return _result, _err
470 }
471 _result = _body
472 return _result, _err
473 }
474
475 // Summary:
476 //
477 // Creates a health check task.
478 //
479 // Description:
480 //
481 // **
482 //
483 // @param request - AddDnsGtmMonitorRequest
484 //
485 // @param runtime - runtime options for this request RuntimeOptions
486 //
487 // @return AddDnsGtmMonitorResponse
488 func AddDnsGtmMonitorWithOptions(client *Client, request *AddDnsGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmMonitorResponse, _err error) {
489 if dara.BoolValue(client.EnableValidate) == true {
490 _err = request.Validate()
491 if _err != nil {
492 return _result, _err
493 }
494 }
495 query := map[string]interface{}{}
496 if !dara.IsNil(request.AddrPoolId) {
497 query["AddrPoolId"] = request.AddrPoolId
498 }
499
500 if !dara.IsNil(request.EvaluationCount) {
501 query["EvaluationCount"] = request.EvaluationCount
502 }
503
504 if !dara.IsNil(request.Interval) {
505 query["Interval"] = request.Interval
506 }
507
508 if !dara.IsNil(request.IspCityNode) {
509 query["IspCityNode"] = request.IspCityNode
510 }
511
512 if !dara.IsNil(request.Lang) {
513 query["Lang"] = request.Lang
514 }
515
516 if !dara.IsNil(request.MonitorExtendInfo) {
517 query["MonitorExtendInfo"] = request.MonitorExtendInfo
518 }
519
520 if !dara.IsNil(request.ProtocolType) {
521 query["ProtocolType"] = request.ProtocolType
522 }
523
524 if !dara.IsNil(request.Timeout) {
525 query["Timeout"] = request.Timeout
526 }
527
528 req := &openapiutil.OpenApiRequest{
529 Query: openapiutil.Query(query),
530 }
531 params := &openapiutil.Params{
532 Action: dara.String("AddDnsGtmMonitor"),
533 Version: dara.String("2015-01-09"),
534 Protocol: dara.String("HTTPS"),
535 Pathname: dara.String("/"),
536 Method: dara.String("POST"),
537 AuthType: dara.String("AK"),
538 Style: dara.String("RPC"),
539 ReqBodyType: dara.String("formData"),
540 BodyType: dara.String("json"),
541 }
542 _result = &AddDnsGtmMonitorResponse{}
543 _body, _err := client.CallApi(params, req, runtime)
544 if _err != nil {
545 return _result, _err
546 }
547 _err = dara.Convert(_body, &_result)
548 return _result, _err
549 }
550
551 // Summary:
552 //
553 // Creates a health check task.
554 //
555 // Description:
556 //
557 // **
558 //
559 // @param request - AddDnsGtmMonitorRequest
560 //
561 // @return AddDnsGtmMonitorResponse
562 func AddDnsGtmMonitor(client *Client, request *AddDnsGtmMonitorRequest) (_result *AddDnsGtmMonitorResponse, _err error) {
563 runtime := &dara.RuntimeOptions{}
564 _result = &AddDnsGtmMonitorResponse{}
565 _body, _err := AddDnsGtmMonitorWithOptions(client,request, runtime)
566 if _err != nil {
567 return _result, _err
568 }
569 _result = _body
570 return _result, _err
571 }
572
573 // Summary:
574 //
575 // Adds a domain name based on the specified parameters.
576 //
577 // Description:
578 //
579 // # For more information about how to check whether a domain name is valid, see
580 //
581 // [Domain name validity](https://www.alibabacloud.com/help/zh/doc-detail/67788.htm).
582 //
583 // @param request - AddDomainRequest
584 //
585 // @param runtime - runtime options for this request RuntimeOptions
586 //
587 // @return AddDomainResponse
588 func AddDomainWithOptions(client *Client, request *AddDomainRequest, runtime *dara.RuntimeOptions) (_result *AddDomainResponse, _err error) {
589 if dara.BoolValue(client.EnableValidate) == true {
590 _err = request.Validate()
591 if _err != nil {
592 return _result, _err
593 }
594 }
595 query := map[string]interface{}{}
596 if !dara.IsNil(request.DomainName) {
597 query["DomainName"] = request.DomainName
598 }
599
600 if !dara.IsNil(request.GroupId) {
601 query["GroupId"] = request.GroupId
602 }
603
604 if !dara.IsNil(request.Lang) {
605 query["Lang"] = request.Lang
606 }
607
608 if !dara.IsNil(request.ResourceGroupId) {
609 query["ResourceGroupId"] = request.ResourceGroupId
610 }
611
612 req := &openapiutil.OpenApiRequest{
613 Query: openapiutil.Query(query),
614 }
615 params := &openapiutil.Params{
616 Action: dara.String("AddDomain"),
617 Version: dara.String("2015-01-09"),
618 Protocol: dara.String("HTTPS"),
619 Pathname: dara.String("/"),
620 Method: dara.String("POST"),
621 AuthType: dara.String("AK"),
622 Style: dara.String("RPC"),
623 ReqBodyType: dara.String("formData"),
624 BodyType: dara.String("json"),
625 }
626 _result = &AddDomainResponse{}
627 _body, _err := client.CallApi(params, req, runtime)
628 if _err != nil {
629 return _result, _err
630 }
631 _err = dara.Convert(_body, &_result)
632 return _result, _err
633 }
634
635 // Summary:
636 //
637 // Adds a domain name based on the specified parameters.
638 //
639 // Description:
640 //
641 // # For more information about how to check whether a domain name is valid, see
642 //
643 // [Domain name validity](https://www.alibabacloud.com/help/zh/doc-detail/67788.htm).
644 //
645 // @param request - AddDomainRequest
646 //
647 // @return AddDomainResponse
648 func AddDomain(client *Client, request *AddDomainRequest) (_result *AddDomainResponse, _err error) {
649 runtime := &dara.RuntimeOptions{}
650 _result = &AddDomainResponse{}
651 _body, _err := AddDomainWithOptions(client,request, runtime)
652 if _err != nil {
653 return _result, _err
654 }
655 _result = _body
656 return _result, _err
657 }
658
659 // Summary:
660 //
661 // Creates a backup task for a domain name.
662 //
663 // @param request - AddDomainBackupRequest
664 //
665 // @param runtime - runtime options for this request RuntimeOptions
666 //
667 // @return AddDomainBackupResponse
668 func AddDomainBackupWithOptions(client *Client, request *AddDomainBackupRequest, runtime *dara.RuntimeOptions) (_result *AddDomainBackupResponse, _err error) {
669 if dara.BoolValue(client.EnableValidate) == true {
670 _err = request.Validate()
671 if _err != nil {
672 return _result, _err
673 }
674 }
675 query := map[string]interface{}{}
676 if !dara.IsNil(request.DomainName) {
677 query["DomainName"] = request.DomainName
678 }
679
680 if !dara.IsNil(request.Lang) {
681 query["Lang"] = request.Lang
682 }
683
684 if !dara.IsNil(request.PeriodType) {
685 query["PeriodType"] = request.PeriodType
686 }
687
688 req := &openapiutil.OpenApiRequest{
689 Query: openapiutil.Query(query),
690 }
691 params := &openapiutil.Params{
692 Action: dara.String("AddDomainBackup"),
693 Version: dara.String("2015-01-09"),
694 Protocol: dara.String("HTTPS"),
695 Pathname: dara.String("/"),
696 Method: dara.String("POST"),
697 AuthType: dara.String("AK"),
698 Style: dara.String("RPC"),
699 ReqBodyType: dara.String("formData"),
700 BodyType: dara.String("json"),
701 }
702 _result = &AddDomainBackupResponse{}
703 _body, _err := client.CallApi(params, req, runtime)
704 if _err != nil {
705 return _result, _err
706 }
707 _err = dara.Convert(_body, &_result)
708 return _result, _err
709 }
710
711 // Summary:
712 //
713 // Creates a backup task for a domain name.
714 //
715 // @param request - AddDomainBackupRequest
716 //
717 // @return AddDomainBackupResponse
718 func AddDomainBackup(client *Client, request *AddDomainBackupRequest) (_result *AddDomainBackupResponse, _err error) {
719 runtime := &dara.RuntimeOptions{}
720 _result = &AddDomainBackupResponse{}
721 _body, _err := AddDomainBackupWithOptions(client,request, runtime)
722 if _err != nil {
723 return _result, _err
724 }
725 _result = _body
726 return _result, _err
727 }
728
729 // Summary:
730 //
731 // Creates a domain name group based on the specified parameters.
732 //
733 // @param request - AddDomainGroupRequest
734 //
735 // @param runtime - runtime options for this request RuntimeOptions
736 //
737 // @return AddDomainGroupResponse
738 func AddDomainGroupWithOptions(client *Client, request *AddDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *AddDomainGroupResponse, _err error) {
739 if dara.BoolValue(client.EnableValidate) == true {
740 _err = request.Validate()
741 if _err != nil {
742 return _result, _err
743 }
744 }
745 query := map[string]interface{}{}
746 if !dara.IsNil(request.GroupName) {
747 query["GroupName"] = request.GroupName
748 }
749
750 if !dara.IsNil(request.Lang) {
751 query["Lang"] = request.Lang
752 }
753
754 req := &openapiutil.OpenApiRequest{
755 Query: openapiutil.Query(query),
756 }
757 params := &openapiutil.Params{
758 Action: dara.String("AddDomainGroup"),
759 Version: dara.String("2015-01-09"),
760 Protocol: dara.String("HTTPS"),
761 Pathname: dara.String("/"),
762 Method: dara.String("POST"),
763 AuthType: dara.String("AK"),
764 Style: dara.String("RPC"),
765 ReqBodyType: dara.String("formData"),
766 BodyType: dara.String("json"),
767 }
768 _result = &AddDomainGroupResponse{}
769 _body, _err := client.CallApi(params, req, runtime)
770 if _err != nil {
771 return _result, _err
772 }
773 _err = dara.Convert(_body, &_result)
774 return _result, _err
775 }
776
777 // Summary:
778 //
779 // Creates a domain name group based on the specified parameters.
780 //
781 // @param request - AddDomainGroupRequest
782 //
783 // @return AddDomainGroupResponse
784 func AddDomainGroup(client *Client, request *AddDomainGroupRequest) (_result *AddDomainGroupResponse, _err error) {
785 runtime := &dara.RuntimeOptions{}
786 _result = &AddDomainGroupResponse{}
787 _body, _err := AddDomainGroupWithOptions(client,request, runtime)
788 if _err != nil {
789 return _result, _err
790 }
791 _result = _body
792 return _result, _err
793 }
794
795 // Summary:
796 //
797 // Adds a Domain Name System (DNS) record based on the specified parameters.
798 //
799 // @param request - AddDomainRecordRequest
800 //
801 // @param runtime - runtime options for this request RuntimeOptions
802 //
803 // @return AddDomainRecordResponse
804 func AddDomainRecordWithOptions(client *Client, request *AddDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *AddDomainRecordResponse, _err error) {
805 if dara.BoolValue(client.EnableValidate) == true {
806 _err = request.Validate()
807 if _err != nil {
808 return _result, _err
809 }
810 }
811 query := map[string]interface{}{}
812 if !dara.IsNil(request.DomainName) {
813 query["DomainName"] = request.DomainName
814 }
815
816 if !dara.IsNil(request.Lang) {
817 query["Lang"] = request.Lang
818 }
819
820 if !dara.IsNil(request.Line) {
821 query["Line"] = request.Line
822 }
823
824 if !dara.IsNil(request.Priority) {
825 query["Priority"] = request.Priority
826 }
827
828 if !dara.IsNil(request.RR) {
829 query["RR"] = request.RR
830 }
831
832 if !dara.IsNil(request.TTL) {
833 query["TTL"] = request.TTL
834 }
835
836 if !dara.IsNil(request.Type) {
837 query["Type"] = request.Type
838 }
839
840 if !dara.IsNil(request.UserClientIp) {
841 query["UserClientIp"] = request.UserClientIp
842 }
843
844 if !dara.IsNil(request.Value) {
845 query["Value"] = request.Value
846 }
847
848 req := &openapiutil.OpenApiRequest{
849 Query: openapiutil.Query(query),
850 }
851 params := &openapiutil.Params{
852 Action: dara.String("AddDomainRecord"),
853 Version: dara.String("2015-01-09"),
854 Protocol: dara.String("HTTPS"),
855 Pathname: dara.String("/"),
856 Method: dara.String("POST"),
857 AuthType: dara.String("AK"),
858 Style: dara.String("RPC"),
859 ReqBodyType: dara.String("formData"),
860 BodyType: dara.String("json"),
861 }
862 _result = &AddDomainRecordResponse{}
863 _body, _err := client.CallApi(params, req, runtime)
864 if _err != nil {
865 return _result, _err
866 }
867 _err = dara.Convert(_body, &_result)
868 return _result, _err
869 }
870
871 // Summary:
872 //
873 // Adds a Domain Name System (DNS) record based on the specified parameters.
874 //
875 // @param request - AddDomainRecordRequest
876 //
877 // @return AddDomainRecordResponse
878 func AddDomainRecord(client *Client, request *AddDomainRecordRequest) (_result *AddDomainRecordResponse, _err error) {
879 runtime := &dara.RuntimeOptions{}
880 _result = &AddDomainRecordResponse{}
881 _body, _err := AddDomainRecordWithOptions(client,request, runtime)
882 if _err != nil {
883 return _result, _err
884 }
885 _result = _body
886 return _result, _err
887 }
888
889 // @param request - AddGtmAccessStrategyRequest
890 //
891 // @param runtime - runtime options for this request RuntimeOptions
892 //
893 // @return AddGtmAccessStrategyResponse
894 func AddGtmAccessStrategyWithOptions(client *Client, request *AddGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *AddGtmAccessStrategyResponse, _err error) {
895 if dara.BoolValue(client.EnableValidate) == true {
896 _err = request.Validate()
897 if _err != nil {
898 return _result, _err
899 }
900 }
901 query := map[string]interface{}{}
902 if !dara.IsNil(request.AccessLines) {
903 query["AccessLines"] = request.AccessLines
904 }
905
906 if !dara.IsNil(request.DefaultAddrPoolId) {
907 query["DefaultAddrPoolId"] = request.DefaultAddrPoolId
908 }
909
910 if !dara.IsNil(request.FailoverAddrPoolId) {
911 query["FailoverAddrPoolId"] = request.FailoverAddrPoolId
912 }
913
914 if !dara.IsNil(request.InstanceId) {
915 query["InstanceId"] = request.InstanceId
916 }
917
918 if !dara.IsNil(request.Lang) {
919 query["Lang"] = request.Lang
920 }
921
922 if !dara.IsNil(request.StrategyName) {
923 query["StrategyName"] = request.StrategyName
924 }
925
926 req := &openapiutil.OpenApiRequest{
927 Query: openapiutil.Query(query),
928 }
929 params := &openapiutil.Params{
930 Action: dara.String("AddGtmAccessStrategy"),
931 Version: dara.String("2015-01-09"),
932 Protocol: dara.String("HTTPS"),
933 Pathname: dara.String("/"),
934 Method: dara.String("POST"),
935 AuthType: dara.String("AK"),
936 Style: dara.String("RPC"),
937 ReqBodyType: dara.String("formData"),
938 BodyType: dara.String("json"),
939 }
940 _result = &AddGtmAccessStrategyResponse{}
941 _body, _err := client.CallApi(params, req, runtime)
942 if _err != nil {
943 return _result, _err
944 }
945 _err = dara.Convert(_body, &_result)
946 return _result, _err
947 }
948
949 // @param request - AddGtmAccessStrategyRequest
950 //
951 // @return AddGtmAccessStrategyResponse
952 func AddGtmAccessStrategy(client *Client, request *AddGtmAccessStrategyRequest) (_result *AddGtmAccessStrategyResponse, _err error) {
953 runtime := &dara.RuntimeOptions{}
954 _result = &AddGtmAccessStrategyResponse{}
955 _body, _err := AddGtmAccessStrategyWithOptions(client,request, runtime)
956 if _err != nil {
957 return _result, _err
958 }
959 _result = _body
960 return _result, _err
961 }
962
963 // Summary:
964 //
965 // Creates an address pool.
966 //
967 // @param request - AddGtmAddressPoolRequest
968 //
969 // @param runtime - runtime options for this request RuntimeOptions
970 //
971 // @return AddGtmAddressPoolResponse
972 func AddGtmAddressPoolWithOptions(client *Client, request *AddGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *AddGtmAddressPoolResponse, _err error) {
973 if dara.BoolValue(client.EnableValidate) == true {
974 _err = request.Validate()
975 if _err != nil {
976 return _result, _err
977 }
978 }
979 query := map[string]interface{}{}
980 if !dara.IsNil(request.Addr) {
981 query["Addr"] = request.Addr
982 }
983
984 if !dara.IsNil(request.EvaluationCount) {
985 query["EvaluationCount"] = request.EvaluationCount
986 }
987
988 if !dara.IsNil(request.InstanceId) {
989 query["InstanceId"] = request.InstanceId
990 }
991
992 if !dara.IsNil(request.Interval) {
993 query["Interval"] = request.Interval
994 }
995
996 if !dara.IsNil(request.IspCityNode) {
997 query["IspCityNode"] = request.IspCityNode
998 }
999
1000 if !dara.IsNil(request.Lang) {
1001 query["Lang"] = request.Lang
1002 }
1003
1004 if !dara.IsNil(request.MinAvailableAddrNum) {
1005 query["MinAvailableAddrNum"] = request.MinAvailableAddrNum
1006 }
1007
1008 if !dara.IsNil(request.MonitorExtendInfo) {
1009 query["MonitorExtendInfo"] = request.MonitorExtendInfo
1010 }
1011
1012 if !dara.IsNil(request.MonitorStatus) {
1013 query["MonitorStatus"] = request.MonitorStatus
1014 }
1015
1016 if !dara.IsNil(request.Name) {
1017 query["Name"] = request.Name
1018 }
1019
1020 if !dara.IsNil(request.ProtocolType) {
1021 query["ProtocolType"] = request.ProtocolType
1022 }
1023
1024 if !dara.IsNil(request.Timeout) {
1025 query["Timeout"] = request.Timeout
1026 }
1027
1028 if !dara.IsNil(request.Type) {
1029 query["Type"] = request.Type
1030 }
1031
1032 req := &openapiutil.OpenApiRequest{
1033 Query: openapiutil.Query(query),
1034 }
1035 params := &openapiutil.Params{
1036 Action: dara.String("AddGtmAddressPool"),
1037 Version: dara.String("2015-01-09"),
1038 Protocol: dara.String("HTTPS"),
1039 Pathname: dara.String("/"),
1040 Method: dara.String("POST"),
1041 AuthType: dara.String("AK"),
1042 Style: dara.String("RPC"),
1043 ReqBodyType: dara.String("formData"),
1044 BodyType: dara.String("json"),
1045 }
1046 _result = &AddGtmAddressPoolResponse{}
1047 _body, _err := client.CallApi(params, req, runtime)
1048 if _err != nil {
1049 return _result, _err
1050 }
1051 _err = dara.Convert(_body, &_result)
1052 return _result, _err
1053 }
1054
1055 // Summary:
1056 //
1057 // Creates an address pool.
1058 //
1059 // @param request - AddGtmAddressPoolRequest
1060 //
1061 // @return AddGtmAddressPoolResponse
1062 func AddGtmAddressPool(client *Client, request *AddGtmAddressPoolRequest) (_result *AddGtmAddressPoolResponse, _err error) {
1063 runtime := &dara.RuntimeOptions{}
1064 _result = &AddGtmAddressPoolResponse{}
1065 _body, _err := AddGtmAddressPoolWithOptions(client,request, runtime)
1066 if _err != nil {
1067 return _result, _err
1068 }
1069 _result = _body
1070 return _result, _err
1071 }
1072
1073 // Summary:
1074 //
1075 // Creates a health check task.
1076 //
1077 // @param request - AddGtmMonitorRequest
1078 //
1079 // @param runtime - runtime options for this request RuntimeOptions
1080 //
1081 // @return AddGtmMonitorResponse
1082 func AddGtmMonitorWithOptions(client *Client, request *AddGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *AddGtmMonitorResponse, _err error) {
1083 if dara.BoolValue(client.EnableValidate) == true {
1084 _err = request.Validate()
1085 if _err != nil {
1086 return _result, _err
1087 }
1088 }
1089 query := map[string]interface{}{}
1090 if !dara.IsNil(request.AddrPoolId) {
1091 query["AddrPoolId"] = request.AddrPoolId
1092 }
1093
1094 if !dara.IsNil(request.EvaluationCount) {
1095 query["EvaluationCount"] = request.EvaluationCount
1096 }
1097
1098 if !dara.IsNil(request.Interval) {
1099 query["Interval"] = request.Interval
1100 }
1101
1102 if !dara.IsNil(request.IspCityNode) {
1103 query["IspCityNode"] = request.IspCityNode
1104 }
1105
1106 if !dara.IsNil(request.Lang) {
1107 query["Lang"] = request.Lang
1108 }
1109
1110 if !dara.IsNil(request.MonitorExtendInfo) {
1111 query["MonitorExtendInfo"] = request.MonitorExtendInfo
1112 }
1113
1114 if !dara.IsNil(request.ProtocolType) {
1115 query["ProtocolType"] = request.ProtocolType
1116 }
1117
1118 if !dara.IsNil(request.Timeout) {
1119 query["Timeout"] = request.Timeout
1120 }
1121
1122 req := &openapiutil.OpenApiRequest{
1123 Query: openapiutil.Query(query),
1124 }
1125 params := &openapiutil.Params{
1126 Action: dara.String("AddGtmMonitor"),
1127 Version: dara.String("2015-01-09"),
1128 Protocol: dara.String("HTTPS"),
1129 Pathname: dara.String("/"),
1130 Method: dara.String("POST"),
1131 AuthType: dara.String("AK"),
1132 Style: dara.String("RPC"),
1133 ReqBodyType: dara.String("formData"),
1134 BodyType: dara.String("json"),
1135 }
1136 _result = &AddGtmMonitorResponse{}
1137 _body, _err := client.CallApi(params, req, runtime)
1138 if _err != nil {
1139 return _result, _err
1140 }
1141 _err = dara.Convert(_body, &_result)
1142 return _result, _err
1143 }
1144
1145 // Summary:
1146 //
1147 // Creates a health check task.
1148 //
1149 // @param request - AddGtmMonitorRequest
1150 //
1151 // @return AddGtmMonitorResponse
1152 func AddGtmMonitor(client *Client, request *AddGtmMonitorRequest) (_result *AddGtmMonitorResponse, _err error) {
1153 runtime := &dara.RuntimeOptions{}
1154 _result = &AddGtmMonitorResponse{}
1155 _body, _err := AddGtmMonitorWithOptions(client,request, runtime)
1156 if _err != nil {
1157 return _result, _err
1158 }
1159 _result = _body
1160 return _result, _err
1161 }
1162
1163 // Summary:
1164 //
1165 // Creates a disaster recovery plan.
1166 //
1167 // @param request - AddGtmRecoveryPlanRequest
1168 //
1169 // @param runtime - runtime options for this request RuntimeOptions
1170 //
1171 // @return AddGtmRecoveryPlanResponse
1172 func AddGtmRecoveryPlanWithOptions(client *Client, request *AddGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *AddGtmRecoveryPlanResponse, _err error) {
1173 if dara.BoolValue(client.EnableValidate) == true {
1174 _err = request.Validate()
1175 if _err != nil {
1176 return _result, _err
1177 }
1178 }
1179 query := map[string]interface{}{}
1180 if !dara.IsNil(request.FaultAddrPool) {
1181 query["FaultAddrPool"] = request.FaultAddrPool
1182 }
1183
1184 if !dara.IsNil(request.Lang) {
1185 query["Lang"] = request.Lang
1186 }
1187
1188 if !dara.IsNil(request.Name) {
1189 query["Name"] = request.Name
1190 }
1191
1192 if !dara.IsNil(request.Remark) {
1193 query["Remark"] = request.Remark
1194 }
1195
1196 req := &openapiutil.OpenApiRequest{
1197 Query: openapiutil.Query(query),
1198 }
1199 params := &openapiutil.Params{
1200 Action: dara.String("AddGtmRecoveryPlan"),
1201 Version: dara.String("2015-01-09"),
1202 Protocol: dara.String("HTTPS"),
1203 Pathname: dara.String("/"),
1204 Method: dara.String("POST"),
1205 AuthType: dara.String("AK"),
1206 Style: dara.String("RPC"),
1207 ReqBodyType: dara.String("formData"),
1208 BodyType: dara.String("json"),
1209 }
1210 _result = &AddGtmRecoveryPlanResponse{}
1211 _body, _err := client.CallApi(params, req, runtime)
1212 if _err != nil {
1213 return _result, _err
1214 }
1215 _err = dara.Convert(_body, &_result)
1216 return _result, _err
1217 }
1218
1219 // Summary:
1220 //
1221 // Creates a disaster recovery plan.
1222 //
1223 // @param request - AddGtmRecoveryPlanRequest
1224 //
1225 // @return AddGtmRecoveryPlanResponse
1226 func AddGtmRecoveryPlan(client *Client, request *AddGtmRecoveryPlanRequest) (_result *AddGtmRecoveryPlanResponse, _err error) {
1227 runtime := &dara.RuntimeOptions{}
1228 _result = &AddGtmRecoveryPlanResponse{}
1229 _body, _err := AddGtmRecoveryPlanWithOptions(client,request, runtime)
1230 if _err != nil {
1231 return _result, _err
1232 }
1233 _result = _body
1234 return _result, _err
1235 }
1236
1237 // Summary:
1238 //
1239 // 新增递归解析内置权威解析记录
1240 //
1241 // @param request - AddRecursionRecordRequest
1242 //
1243 // @param runtime - runtime options for this request RuntimeOptions
1244 //
1245 // @return AddRecursionRecordResponse
1246 func AddRecursionRecordWithOptions(client *Client, request *AddRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *AddRecursionRecordResponse, _err error) {
1247 if dara.BoolValue(client.EnableValidate) == true {
1248 _err = request.Validate()
1249 if _err != nil {
1250 return _result, _err
1251 }
1252 }
1253 query := map[string]interface{}{}
1254 if !dara.IsNil(request.ClientToken) {
1255 query["ClientToken"] = request.ClientToken
1256 }
1257
1258 if !dara.IsNil(request.Priority) {
1259 query["Priority"] = request.Priority
1260 }
1261
1262 if !dara.IsNil(request.RequestSource) {
1263 query["RequestSource"] = request.RequestSource
1264 }
1265
1266 if !dara.IsNil(request.Rr) {
1267 query["Rr"] = request.Rr
1268 }
1269
1270 if !dara.IsNil(request.Ttl) {
1271 query["Ttl"] = request.Ttl
1272 }
1273
1274 if !dara.IsNil(request.Type) {
1275 query["Type"] = request.Type
1276 }
1277
1278 if !dara.IsNil(request.UserClientIp) {
1279 query["UserClientIp"] = request.UserClientIp
1280 }
1281
1282 if !dara.IsNil(request.Value) {
1283 query["Value"] = request.Value
1284 }
1285
1286 if !dara.IsNil(request.Weight) {
1287 query["Weight"] = request.Weight
1288 }
1289
1290 if !dara.IsNil(request.ZoneId) {
1291 query["ZoneId"] = request.ZoneId
1292 }
1293
1294 req := &openapiutil.OpenApiRequest{
1295 Query: openapiutil.Query(query),
1296 }
1297 params := &openapiutil.Params{
1298 Action: dara.String("AddRecursionRecord"),
1299 Version: dara.String("2015-01-09"),
1300 Protocol: dara.String("HTTPS"),
1301 Pathname: dara.String("/"),
1302 Method: dara.String("POST"),
1303 AuthType: dara.String("AK"),
1304 Style: dara.String("RPC"),
1305 ReqBodyType: dara.String("formData"),
1306 BodyType: dara.String("json"),
1307 }
1308 _result = &AddRecursionRecordResponse{}
1309 _body, _err := client.CallApi(params, req, runtime)
1310 if _err != nil {
1311 return _result, _err
1312 }
1313 _err = dara.Convert(_body, &_result)
1314 return _result, _err
1315 }
1316
1317 // Summary:
1318 //
1319 // 新增递归解析内置权威解析记录
1320 //
1321 // @param request - AddRecursionRecordRequest
1322 //
1323 // @return AddRecursionRecordResponse
1324 func AddRecursionRecord(client *Client, request *AddRecursionRecordRequest) (_result *AddRecursionRecordResponse, _err error) {
1325 runtime := &dara.RuntimeOptions{}
1326 _result = &AddRecursionRecordResponse{}
1327 _body, _err := AddRecursionRecordWithOptions(client,request, runtime)
1328 if _err != nil {
1329 return _result, _err
1330 }
1331 _result = _body
1332 return _result, _err
1333 }
1334
1335 // Summary:
1336 //
1337 // 新增递归解析内置权威域名zone
1338 //
1339 // @param request - AddRecursionZoneRequest
1340 //
1341 // @param runtime - runtime options for this request RuntimeOptions
1342 //
1343 // @return AddRecursionZoneResponse
1344 func AddRecursionZoneWithOptions(client *Client, request *AddRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *AddRecursionZoneResponse, _err error) {
1345 if dara.BoolValue(client.EnableValidate) == true {
1346 _err = request.Validate()
1347 if _err != nil {
1348 return _result, _err
1349 }
1350 }
1351 query := map[string]interface{}{}
1352 if !dara.IsNil(request.ClientToken) {
1353 query["ClientToken"] = request.ClientToken
1354 }
1355
1356 if !dara.IsNil(request.ProxyPattern) {
1357 query["ProxyPattern"] = request.ProxyPattern
1358 }
1359
1360 if !dara.IsNil(request.ZoneName) {
1361 query["ZoneName"] = request.ZoneName
1362 }
1363
1364 req := &openapiutil.OpenApiRequest{
1365 Query: openapiutil.Query(query),
1366 }
1367 params := &openapiutil.Params{
1368 Action: dara.String("AddRecursionZone"),
1369 Version: dara.String("2015-01-09"),
1370 Protocol: dara.String("HTTPS"),
1371 Pathname: dara.String("/"),
1372 Method: dara.String("POST"),
1373 AuthType: dara.String("AK"),
1374 Style: dara.String("RPC"),
1375 ReqBodyType: dara.String("formData"),
1376 BodyType: dara.String("json"),
1377 }
1378 _result = &AddRecursionZoneResponse{}
1379 _body, _err := client.CallApi(params, req, runtime)
1380 if _err != nil {
1381 return _result, _err
1382 }
1383 _err = dara.Convert(_body, &_result)
1384 return _result, _err
1385 }
1386
1387 // Summary:
1388 //
1389 // 新增递归解析内置权威域名zone
1390 //
1391 // @param request - AddRecursionZoneRequest
1392 //
1393 // @return AddRecursionZoneResponse
1394 func AddRecursionZone(client *Client, request *AddRecursionZoneRequest) (_result *AddRecursionZoneResponse, _err error) {
1395 runtime := &dara.RuntimeOptions{}
1396 _result = &AddRecursionZoneResponse{}
1397 _body, _err := AddRecursionZoneWithOptions(client,request, runtime)
1398 if _err != nil {
1399 return _result, _err
1400 }
1401 _result = _body
1402 return _result, _err
1403 }
1404
1405 // Summary:
1406 //
1407 // Binds one or more domain names to a paid Alibaba Cloud DNS instance.
1408 //
1409 // Description:
1410 //
1411 // A paid Alibaba Cloud DNS instance whose ID starts with dns is an instance of the new version. You can call this API operation to bind multiple domain names to the instance. If the upper limit is exceeded, an error message is returned.\\
1412 //
1413 // A paid Alibaba Cloud DNS instance whose ID does not start with dns is an instance of the old version. You can call this API operation to bind only one domain name to the instance. However, if the instance is already bound to a domain name, you must unbind the original domain name from the instance and bind the desired domain name to the instance.
1414 //
1415 // @param request - BindInstanceDomainsRequest
1416 //
1417 // @param runtime - runtime options for this request RuntimeOptions
1418 //
1419 // @return BindInstanceDomainsResponse
1420 func BindInstanceDomainsWithOptions(client *Client, request *BindInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *BindInstanceDomainsResponse, _err error) {
1421 if dara.BoolValue(client.EnableValidate) == true {
1422 _err = request.Validate()
1423 if _err != nil {
1424 return _result, _err
1425 }
1426 }
1427 query := map[string]interface{}{}
1428 if !dara.IsNil(request.DomainNames) {
1429 query["DomainNames"] = request.DomainNames
1430 }
1431
1432 if !dara.IsNil(request.InstanceId) {
1433 query["InstanceId"] = request.InstanceId
1434 }
1435
1436 if !dara.IsNil(request.Lang) {
1437 query["Lang"] = request.Lang
1438 }
1439
1440 req := &openapiutil.OpenApiRequest{
1441 Query: openapiutil.Query(query),
1442 }
1443 params := &openapiutil.Params{
1444 Action: dara.String("BindInstanceDomains"),
1445 Version: dara.String("2015-01-09"),
1446 Protocol: dara.String("HTTPS"),
1447 Pathname: dara.String("/"),
1448 Method: dara.String("POST"),
1449 AuthType: dara.String("AK"),
1450 Style: dara.String("RPC"),
1451 ReqBodyType: dara.String("formData"),
1452 BodyType: dara.String("json"),
1453 }
1454 _result = &BindInstanceDomainsResponse{}
1455 _body, _err := client.CallApi(params, req, runtime)
1456 if _err != nil {
1457 return _result, _err
1458 }
1459 _err = dara.Convert(_body, &_result)
1460 return _result, _err
1461 }
1462
1463 // Summary:
1464 //
1465 // Binds one or more domain names to a paid Alibaba Cloud DNS instance.
1466 //
1467 // Description:
1468 //
1469 // A paid Alibaba Cloud DNS instance whose ID starts with dns is an instance of the new version. You can call this API operation to bind multiple domain names to the instance. If the upper limit is exceeded, an error message is returned.\\
1470 //
1471 // A paid Alibaba Cloud DNS instance whose ID does not start with dns is an instance of the old version. You can call this API operation to bind only one domain name to the instance. However, if the instance is already bound to a domain name, you must unbind the original domain name from the instance and bind the desired domain name to the instance.
1472 //
1473 // @param request - BindInstanceDomainsRequest
1474 //
1475 // @return BindInstanceDomainsResponse
1476 func BindInstanceDomains(client *Client, request *BindInstanceDomainsRequest) (_result *BindInstanceDomainsResponse, _err error) {
1477 runtime := &dara.RuntimeOptions{}
1478 _result = &BindInstanceDomainsResponse{}
1479 _body, _err := BindInstanceDomainsWithOptions(client,request, runtime)
1480 if _err != nil {
1481 return _result, _err
1482 }
1483 _result = _body
1484 return _result, _err
1485 }
1486
1487 // Summary:
1488 //
1489 // Moves a domain name from the original group to the new group based on the specified parameters.
1490 //
1491 // Description:
1492 //
1493 // You can specify GroupId to move a domain name to a specific domain name group. You can move the domain name to the group that contains all domain names or the default group.
1494 //
1495 // @param request - ChangeDomainGroupRequest
1496 //
1497 // @param runtime - runtime options for this request RuntimeOptions
1498 //
1499 // @return ChangeDomainGroupResponse
1500 func ChangeDomainGroupWithOptions(client *Client, request *ChangeDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *ChangeDomainGroupResponse, _err error) {
1501 if dara.BoolValue(client.EnableValidate) == true {
1502 _err = request.Validate()
1503 if _err != nil {
1504 return _result, _err
1505 }
1506 }
1507 query := map[string]interface{}{}
1508 if !dara.IsNil(request.DomainName) {
1509 query["DomainName"] = request.DomainName
1510 }
1511
1512 if !dara.IsNil(request.GroupId) {
1513 query["GroupId"] = request.GroupId
1514 }
1515
1516 if !dara.IsNil(request.Lang) {
1517 query["Lang"] = request.Lang
1518 }
1519
1520 req := &openapiutil.OpenApiRequest{
1521 Query: openapiutil.Query(query),
1522 }
1523 params := &openapiutil.Params{
1524 Action: dara.String("ChangeDomainGroup"),
1525 Version: dara.String("2015-01-09"),
1526 Protocol: dara.String("HTTPS"),
1527 Pathname: dara.String("/"),
1528 Method: dara.String("POST"),
1529 AuthType: dara.String("AK"),
1530 Style: dara.String("RPC"),
1531 ReqBodyType: dara.String("formData"),
1532 BodyType: dara.String("json"),
1533 }
1534 _result = &ChangeDomainGroupResponse{}
1535 _body, _err := client.CallApi(params, req, runtime)
1536 if _err != nil {
1537 return _result, _err
1538 }
1539 _err = dara.Convert(_body, &_result)
1540 return _result, _err
1541 }
1542
1543 // Summary:
1544 //
1545 // Moves a domain name from the original group to the new group based on the specified parameters.
1546 //
1547 // Description:
1548 //
1549 // You can specify GroupId to move a domain name to a specific domain name group. You can move the domain name to the group that contains all domain names or the default group.
1550 //
1551 // @param request - ChangeDomainGroupRequest
1552 //
1553 // @return ChangeDomainGroupResponse
1554 func ChangeDomainGroup(client *Client, request *ChangeDomainGroupRequest) (_result *ChangeDomainGroupResponse, _err error) {
1555 runtime := &dara.RuntimeOptions{}
1556 _result = &ChangeDomainGroupResponse{}
1557 _body, _err := ChangeDomainGroupWithOptions(client,request, runtime)
1558 if _err != nil {
1559 return _result, _err
1560 }
1561 _result = _body
1562 return _result, _err
1563 }
1564
1565 // Summary:
1566 //
1567 // Changes the domain name that is bound to an Alibaba Cloud DNS instance.
1568 //
1569 // Description:
1570 //
1571 // **You can call this operation regardless of whether the Alibaba Cloud DNS instance is bound to a domain name. You can also call this operation to unbind the domain name from the Alibaba Cloud DNS instance by leaving the NewDomain parameter empty.**
1572 //
1573 // - **This operation applies to instances of the custom edition. To change the domain name that is bound to an Alibaba Cloud DNS instance of Personal Edition, Enterprise Standard Edition, or Enterprise Ultimate Edition, call the BindInstanceDomains operation.
1574 //
1575 // @param request - ChangeDomainOfDnsProductRequest
1576 //
1577 // @param runtime - runtime options for this request RuntimeOptions
1578 //
1579 // @return ChangeDomainOfDnsProductResponse
1580 func ChangeDomainOfDnsProductWithOptions(client *Client, request *ChangeDomainOfDnsProductRequest, runtime *dara.RuntimeOptions) (_result *ChangeDomainOfDnsProductResponse, _err error) {
1581 if dara.BoolValue(client.EnableValidate) == true {
1582 _err = request.Validate()
1583 if _err != nil {
1584 return _result, _err
1585 }
1586 }
1587 query := map[string]interface{}{}
1588 if !dara.IsNil(request.Force) {
1589 query["Force"] = request.Force
1590 }
1591
1592 if !dara.IsNil(request.InstanceId) {
1593 query["InstanceId"] = request.InstanceId
1594 }
1595
1596 if !dara.IsNil(request.Lang) {
1597 query["Lang"] = request.Lang
1598 }
1599
1600 if !dara.IsNil(request.NewDomain) {
1601 query["NewDomain"] = request.NewDomain
1602 }
1603
1604 if !dara.IsNil(request.UserClientIp) {
1605 query["UserClientIp"] = request.UserClientIp
1606 }
1607
1608 req := &openapiutil.OpenApiRequest{
1609 Query: openapiutil.Query(query),
1610 }
1611 params := &openapiutil.Params{
1612 Action: dara.String("ChangeDomainOfDnsProduct"),
1613 Version: dara.String("2015-01-09"),
1614 Protocol: dara.String("HTTPS"),
1615 Pathname: dara.String("/"),
1616 Method: dara.String("POST"),
1617 AuthType: dara.String("AK"),
1618 Style: dara.String("RPC"),
1619 ReqBodyType: dara.String("formData"),
1620 BodyType: dara.String("json"),
1621 }
1622 _result = &ChangeDomainOfDnsProductResponse{}
1623 _body, _err := client.CallApi(params, req, runtime)
1624 if _err != nil {
1625 return _result, _err
1626 }
1627 _err = dara.Convert(_body, &_result)
1628 return _result, _err
1629 }
1630
1631 // Summary:
1632 //
1633 // Changes the domain name that is bound to an Alibaba Cloud DNS instance.
1634 //
1635 // Description:
1636 //
1637 // **You can call this operation regardless of whether the Alibaba Cloud DNS instance is bound to a domain name. You can also call this operation to unbind the domain name from the Alibaba Cloud DNS instance by leaving the NewDomain parameter empty.**
1638 //
1639 // - **This operation applies to instances of the custom edition. To change the domain name that is bound to an Alibaba Cloud DNS instance of Personal Edition, Enterprise Standard Edition, or Enterprise Ultimate Edition, call the BindInstanceDomains operation.
1640 //
1641 // @param request - ChangeDomainOfDnsProductRequest
1642 //
1643 // @return ChangeDomainOfDnsProductResponse
1644 func ChangeDomainOfDnsProduct(client *Client, request *ChangeDomainOfDnsProductRequest) (_result *ChangeDomainOfDnsProductResponse, _err error) {
1645 runtime := &dara.RuntimeOptions{}
1646 _result = &ChangeDomainOfDnsProductResponse{}
1647 _body, _err := ChangeDomainOfDnsProductWithOptions(client,request, runtime)
1648 if _err != nil {
1649 return _result, _err
1650 }
1651 _result = _body
1652 return _result, _err
1653 }
1654
1655 // Summary:
1656 //
1657 // Copies the configurations of a Global Traffic Manager (GTM) instance.
1658 //
1659 // @param request - CopyGtmConfigRequest
1660 //
1661 // @param runtime - runtime options for this request RuntimeOptions
1662 //
1663 // @return CopyGtmConfigResponse
1664 func CopyGtmConfigWithOptions(client *Client, request *CopyGtmConfigRequest, runtime *dara.RuntimeOptions) (_result *CopyGtmConfigResponse, _err error) {
1665 if dara.BoolValue(client.EnableValidate) == true {
1666 _err = request.Validate()
1667 if _err != nil {
1668 return _result, _err
1669 }
1670 }
1671 query := map[string]interface{}{}
1672 if !dara.IsNil(request.CopyType) {
1673 query["CopyType"] = request.CopyType
1674 }
1675
1676 if !dara.IsNil(request.Lang) {
1677 query["Lang"] = request.Lang
1678 }
1679
1680 if !dara.IsNil(request.SourceId) {
1681 query["SourceId"] = request.SourceId
1682 }
1683
1684 if !dara.IsNil(request.TargetId) {
1685 query["TargetId"] = request.TargetId
1686 }
1687
1688 req := &openapiutil.OpenApiRequest{
1689 Query: openapiutil.Query(query),
1690 }
1691 params := &openapiutil.Params{
1692 Action: dara.String("CopyGtmConfig"),
1693 Version: dara.String("2015-01-09"),
1694 Protocol: dara.String("HTTPS"),
1695 Pathname: dara.String("/"),
1696 Method: dara.String("POST"),
1697 AuthType: dara.String("AK"),
1698 Style: dara.String("RPC"),
1699 ReqBodyType: dara.String("formData"),
1700 BodyType: dara.String("json"),
1701 }
1702 _result = &CopyGtmConfigResponse{}
1703 _body, _err := client.CallApi(params, req, runtime)
1704 if _err != nil {
1705 return _result, _err
1706 }
1707 _err = dara.Convert(_body, &_result)
1708 return _result, _err
1709 }
1710
1711 // Summary:
1712 //
1713 // Copies the configurations of a Global Traffic Manager (GTM) instance.
1714 //
1715 // @param request - CopyGtmConfigRequest
1716 //
1717 // @return CopyGtmConfigResponse
1718 func CopyGtmConfig(client *Client, request *CopyGtmConfigRequest) (_result *CopyGtmConfigResponse, _err error) {
1719 runtime := &dara.RuntimeOptions{}
1720 _result = &CopyGtmConfigResponse{}
1721 _body, _err := CopyGtmConfigWithOptions(client,request, runtime)
1722 if _err != nil {
1723 return _result, _err
1724 }
1725 _result = _body
1726 return _result, _err
1727 }
1728
1729 // Summary:
1730 //
1731 // Creates an address.
1732 //
1733 // @param tmpReq - CreateCloudGtmAddressRequest
1734 //
1735 // @param runtime - runtime options for this request RuntimeOptions
1736 //
1737 // @return CreateCloudGtmAddressResponse
1738 func CreateCloudGtmAddressWithOptions(client *Client, tmpReq *CreateCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmAddressResponse, _err error) {
1739 if dara.BoolValue(client.EnableValidate) == true {
1740 _err = tmpReq.Validate()
1741 if _err != nil {
1742 return _result, _err
1743 }
1744 }
1745 request := &CreateCloudGtmAddressShrinkRequest{}
1746 openapiutil.Convert(tmpReq, request)
1747 if !dara.IsNil(tmpReq.HealthTasks) {
1748 request.HealthTasksShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HealthTasks, dara.String("HealthTasks"), dara.String("json"))
1749 }
1750
1751 query := map[string]interface{}{}
1752 if !dara.IsNil(request.AcceptLanguage) {
1753 query["AcceptLanguage"] = request.AcceptLanguage
1754 }
1755
1756 if !dara.IsNil(request.Address) {
1757 query["Address"] = request.Address
1758 }
1759
1760 if !dara.IsNil(request.AttributeInfo) {
1761 query["AttributeInfo"] = request.AttributeInfo
1762 }
1763
1764 if !dara.IsNil(request.AvailableMode) {
1765 query["AvailableMode"] = request.AvailableMode
1766 }
1767
1768 if !dara.IsNil(request.ClientToken) {
1769 query["ClientToken"] = request.ClientToken
1770 }
1771
1772 if !dara.IsNil(request.EnableStatus) {
1773 query["EnableStatus"] = request.EnableStatus
1774 }
1775
1776 if !dara.IsNil(request.HealthJudgement) {
1777 query["HealthJudgement"] = request.HealthJudgement
1778 }
1779
1780 if !dara.IsNil(request.HealthTasksShrink) {
1781 query["HealthTasks"] = request.HealthTasksShrink
1782 }
1783
1784 if !dara.IsNil(request.ManualAvailableStatus) {
1785 query["ManualAvailableStatus"] = request.ManualAvailableStatus
1786 }
1787
1788 if !dara.IsNil(request.Name) {
1789 query["Name"] = request.Name
1790 }
1791
1792 if !dara.IsNil(request.Remark) {
1793 query["Remark"] = request.Remark
1794 }
1795
1796 if !dara.IsNil(request.Type) {
1797 query["Type"] = request.Type
1798 }
1799
1800 req := &openapiutil.OpenApiRequest{
1801 Query: openapiutil.Query(query),
1802 }
1803 params := &openapiutil.Params{
1804 Action: dara.String("CreateCloudGtmAddress"),
1805 Version: dara.String("2015-01-09"),
1806 Protocol: dara.String("HTTPS"),
1807 Pathname: dara.String("/"),
1808 Method: dara.String("POST"),
1809 AuthType: dara.String("AK"),
1810 Style: dara.String("RPC"),
1811 ReqBodyType: dara.String("formData"),
1812 BodyType: dara.String("json"),
1813 }
1814 _result = &CreateCloudGtmAddressResponse{}
1815 _body, _err := client.CallApi(params, req, runtime)
1816 if _err != nil {
1817 return _result, _err
1818 }
1819 _err = dara.Convert(_body, &_result)
1820 return _result, _err
1821 }
1822
1823 // Summary:
1824 //
1825 // Creates an address.
1826 //
1827 // @param request - CreateCloudGtmAddressRequest
1828 //
1829 // @return CreateCloudGtmAddressResponse
1830 func CreateCloudGtmAddress(client *Client, request *CreateCloudGtmAddressRequest) (_result *CreateCloudGtmAddressResponse, _err error) {
1831 runtime := &dara.RuntimeOptions{}
1832 _result = &CreateCloudGtmAddressResponse{}
1833 _body, _err := CreateCloudGtmAddressWithOptions(client,request, runtime)
1834 if _err != nil {
1835 return _result, _err
1836 }
1837 _result = _body
1838 return _result, _err
1839 }
1840
1841 // Summary:
1842 //
1843 // Creates an address pool.
1844 //
1845 // @param request - CreateCloudGtmAddressPoolRequest
1846 //
1847 // @param runtime - runtime options for this request RuntimeOptions
1848 //
1849 // @return CreateCloudGtmAddressPoolResponse
1850 func CreateCloudGtmAddressPoolWithOptions(client *Client, request *CreateCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmAddressPoolResponse, _err error) {
1851 if dara.BoolValue(client.EnableValidate) == true {
1852 _err = request.Validate()
1853 if _err != nil {
1854 return _result, _err
1855 }
1856 }
1857 query := map[string]interface{}{}
1858 if !dara.IsNil(request.AcceptLanguage) {
1859 query["AcceptLanguage"] = request.AcceptLanguage
1860 }
1861
1862 if !dara.IsNil(request.AddressPoolName) {
1863 query["AddressPoolName"] = request.AddressPoolName
1864 }
1865
1866 if !dara.IsNil(request.AddressPoolType) {
1867 query["AddressPoolType"] = request.AddressPoolType
1868 }
1869
1870 if !dara.IsNil(request.ClientToken) {
1871 query["ClientToken"] = request.ClientToken
1872 }
1873
1874 if !dara.IsNil(request.EnableStatus) {
1875 query["EnableStatus"] = request.EnableStatus
1876 }
1877
1878 if !dara.IsNil(request.HealthJudgement) {
1879 query["HealthJudgement"] = request.HealthJudgement
1880 }
1881
1882 if !dara.IsNil(request.Remark) {
1883 query["Remark"] = request.Remark
1884 }
1885
1886 req := &openapiutil.OpenApiRequest{
1887 Query: openapiutil.Query(query),
1888 }
1889 params := &openapiutil.Params{
1890 Action: dara.String("CreateCloudGtmAddressPool"),
1891 Version: dara.String("2015-01-09"),
1892 Protocol: dara.String("HTTPS"),
1893 Pathname: dara.String("/"),
1894 Method: dara.String("POST"),
1895 AuthType: dara.String("AK"),
1896 Style: dara.String("RPC"),
1897 ReqBodyType: dara.String("formData"),
1898 BodyType: dara.String("json"),
1899 }
1900 _result = &CreateCloudGtmAddressPoolResponse{}
1901 _body, _err := client.CallApi(params, req, runtime)
1902 if _err != nil {
1903 return _result, _err
1904 }
1905 _err = dara.Convert(_body, &_result)
1906 return _result, _err
1907 }
1908
1909 // Summary:
1910 //
1911 // Creates an address pool.
1912 //
1913 // @param request - CreateCloudGtmAddressPoolRequest
1914 //
1915 // @return CreateCloudGtmAddressPoolResponse
1916 func CreateCloudGtmAddressPool(client *Client, request *CreateCloudGtmAddressPoolRequest) (_result *CreateCloudGtmAddressPoolResponse, _err error) {
1917 runtime := &dara.RuntimeOptions{}
1918 _result = &CreateCloudGtmAddressPoolResponse{}
1919 _body, _err := CreateCloudGtmAddressPoolWithOptions(client,request, runtime)
1920 if _err != nil {
1921 return _result, _err
1922 }
1923 _result = _body
1924 return _result, _err
1925 }
1926
1927 // Summary:
1928 //
1929 // 创建gtm实例配置
1930 //
1931 // @param request - CreateCloudGtmInstanceConfigRequest
1932 //
1933 // @param runtime - runtime options for this request RuntimeOptions
1934 //
1935 // @return CreateCloudGtmInstanceConfigResponse
1936 func CreateCloudGtmInstanceConfigWithOptions(client *Client, request *CreateCloudGtmInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmInstanceConfigResponse, _err error) {
1937 if dara.BoolValue(client.EnableValidate) == true {
1938 _err = request.Validate()
1939 if _err != nil {
1940 return _result, _err
1941 }
1942 }
1943 query := map[string]interface{}{}
1944 if !dara.IsNil(request.AcceptLanguage) {
1945 query["AcceptLanguage"] = request.AcceptLanguage
1946 }
1947
1948 if !dara.IsNil(request.ChargeType) {
1949 query["ChargeType"] = request.ChargeType
1950 }
1951
1952 if !dara.IsNil(request.ClientToken) {
1953 query["ClientToken"] = request.ClientToken
1954 }
1955
1956 if !dara.IsNil(request.EnableStatus) {
1957 query["EnableStatus"] = request.EnableStatus
1958 }
1959
1960 if !dara.IsNil(request.InstanceId) {
1961 query["InstanceId"] = request.InstanceId
1962 }
1963
1964 if !dara.IsNil(request.Remark) {
1965 query["Remark"] = request.Remark
1966 }
1967
1968 if !dara.IsNil(request.ScheduleHostname) {
1969 query["ScheduleHostname"] = request.ScheduleHostname
1970 }
1971
1972 if !dara.IsNil(request.ScheduleRrType) {
1973 query["ScheduleRrType"] = request.ScheduleRrType
1974 }
1975
1976 if !dara.IsNil(request.ScheduleZoneMode) {
1977 query["ScheduleZoneMode"] = request.ScheduleZoneMode
1978 }
1979
1980 if !dara.IsNil(request.ScheduleZoneName) {
1981 query["ScheduleZoneName"] = request.ScheduleZoneName
1982 }
1983
1984 if !dara.IsNil(request.Ttl) {
1985 query["Ttl"] = request.Ttl
1986 }
1987
1988 req := &openapiutil.OpenApiRequest{
1989 Query: openapiutil.Query(query),
1990 }
1991 params := &openapiutil.Params{
1992 Action: dara.String("CreateCloudGtmInstanceConfig"),
1993 Version: dara.String("2015-01-09"),
1994 Protocol: dara.String("HTTPS"),
1995 Pathname: dara.String("/"),
1996 Method: dara.String("POST"),
1997 AuthType: dara.String("AK"),
1998 Style: dara.String("RPC"),
1999 ReqBodyType: dara.String("formData"),
2000 BodyType: dara.String("json"),
2001 }
2002 _result = &CreateCloudGtmInstanceConfigResponse{}
2003 _body, _err := client.CallApi(params, req, runtime)
2004 if _err != nil {
2005 return _result, _err
2006 }
2007 _err = dara.Convert(_body, &_result)
2008 return _result, _err
2009 }
2010
2011 // Summary:
2012 //
2013 // 创建gtm实例配置
2014 //
2015 // @param request - CreateCloudGtmInstanceConfigRequest
2016 //
2017 // @return CreateCloudGtmInstanceConfigResponse
2018 func CreateCloudGtmInstanceConfig(client *Client, request *CreateCloudGtmInstanceConfigRequest) (_result *CreateCloudGtmInstanceConfigResponse, _err error) {
2019 runtime := &dara.RuntimeOptions{}
2020 _result = &CreateCloudGtmInstanceConfigResponse{}
2021 _body, _err := CreateCloudGtmInstanceConfigWithOptions(client,request, runtime)
2022 if _err != nil {
2023 return _result, _err
2024 }
2025 _result = _body
2026 return _result, _err
2027 }
2028
2029 // Summary:
2030 //
2031 // Creates a health check template.
2032 //
2033 // @param tmpReq - CreateCloudGtmMonitorTemplateRequest
2034 //
2035 // @param runtime - runtime options for this request RuntimeOptions
2036 //
2037 // @return CreateCloudGtmMonitorTemplateResponse
2038 func CreateCloudGtmMonitorTemplateWithOptions(client *Client, tmpReq *CreateCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmMonitorTemplateResponse, _err error) {
2039 if dara.BoolValue(client.EnableValidate) == true {
2040 _err = tmpReq.Validate()
2041 if _err != nil {
2042 return _result, _err
2043 }
2044 }
2045 request := &CreateCloudGtmMonitorTemplateShrinkRequest{}
2046 openapiutil.Convert(tmpReq, request)
2047 if !dara.IsNil(tmpReq.IspCityNodes) {
2048 request.IspCityNodesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.IspCityNodes, dara.String("IspCityNodes"), dara.String("json"))
2049 }
2050
2051 query := map[string]interface{}{}
2052 if !dara.IsNil(request.AcceptLanguage) {
2053 query["AcceptLanguage"] = request.AcceptLanguage
2054 }
2055
2056 if !dara.IsNil(request.ClientToken) {
2057 query["ClientToken"] = request.ClientToken
2058 }
2059
2060 if !dara.IsNil(request.EvaluationCount) {
2061 query["EvaluationCount"] = request.EvaluationCount
2062 }
2063
2064 if !dara.IsNil(request.ExtendInfo) {
2065 query["ExtendInfo"] = request.ExtendInfo
2066 }
2067
2068 if !dara.IsNil(request.FailureRate) {
2069 query["FailureRate"] = request.FailureRate
2070 }
2071
2072 if !dara.IsNil(request.Interval) {
2073 query["Interval"] = request.Interval
2074 }
2075
2076 if !dara.IsNil(request.IpVersion) {
2077 query["IpVersion"] = request.IpVersion
2078 }
2079
2080 if !dara.IsNil(request.IspCityNodesShrink) {
2081 query["IspCityNodes"] = request.IspCityNodesShrink
2082 }
2083
2084 if !dara.IsNil(request.Name) {
2085 query["Name"] = request.Name
2086 }
2087
2088 if !dara.IsNil(request.Protocol) {
2089 query["Protocol"] = request.Protocol
2090 }
2091
2092 if !dara.IsNil(request.Timeout) {
2093 query["Timeout"] = request.Timeout
2094 }
2095
2096 req := &openapiutil.OpenApiRequest{
2097 Query: openapiutil.Query(query),
2098 }
2099 params := &openapiutil.Params{
2100 Action: dara.String("CreateCloudGtmMonitorTemplate"),
2101 Version: dara.String("2015-01-09"),
2102 Protocol: dara.String("HTTPS"),
2103 Pathname: dara.String("/"),
2104 Method: dara.String("POST"),
2105 AuthType: dara.String("AK"),
2106 Style: dara.String("RPC"),
2107 ReqBodyType: dara.String("formData"),
2108 BodyType: dara.String("json"),
2109 }
2110 _result = &CreateCloudGtmMonitorTemplateResponse{}
2111 _body, _err := client.CallApi(params, req, runtime)
2112 if _err != nil {
2113 return _result, _err
2114 }
2115 _err = dara.Convert(_body, &_result)
2116 return _result, _err
2117 }
2118
2119 // Summary:
2120 //
2121 // Creates a health check template.
2122 //
2123 // @param request - CreateCloudGtmMonitorTemplateRequest
2124 //
2125 // @return CreateCloudGtmMonitorTemplateResponse
2126 func CreateCloudGtmMonitorTemplate(client *Client, request *CreateCloudGtmMonitorTemplateRequest) (_result *CreateCloudGtmMonitorTemplateResponse, _err error) {
2127 runtime := &dara.RuntimeOptions{}
2128 _result = &CreateCloudGtmMonitorTemplateResponse{}
2129 _body, _err := CreateCloudGtmMonitorTemplateWithOptions(client,request, runtime)
2130 if _err != nil {
2131 return _result, _err
2132 }
2133 _result = _body
2134 return _result, _err
2135 }
2136
2137 // Summary:
2138 //
2139 // 创建公共DNS AppKey
2140 //
2141 // @param request - CreatePdnsAppKeyRequest
2142 //
2143 // @param runtime - runtime options for this request RuntimeOptions
2144 //
2145 // @return CreatePdnsAppKeyResponse
2146 func CreatePdnsAppKeyWithOptions(client *Client, request *CreatePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *CreatePdnsAppKeyResponse, _err error) {
2147 if dara.BoolValue(client.EnableValidate) == true {
2148 _err = request.Validate()
2149 if _err != nil {
2150 return _result, _err
2151 }
2152 }
2153 query := map[string]interface{}{}
2154 if !dara.IsNil(request.Lang) {
2155 query["Lang"] = request.Lang
2156 }
2157
2158 if !dara.IsNil(request.Remark) {
2159 query["Remark"] = request.Remark
2160 }
2161
2162 req := &openapiutil.OpenApiRequest{
2163 Query: openapiutil.Query(query),
2164 }
2165 params := &openapiutil.Params{
2166 Action: dara.String("CreatePdnsAppKey"),
2167 Version: dara.String("2015-01-09"),
2168 Protocol: dara.String("HTTPS"),
2169 Pathname: dara.String("/"),
2170 Method: dara.String("POST"),
2171 AuthType: dara.String("AK"),
2172 Style: dara.String("RPC"),
2173 ReqBodyType: dara.String("formData"),
2174 BodyType: dara.String("json"),
2175 }
2176 _result = &CreatePdnsAppKeyResponse{}
2177 _body, _err := client.CallApi(params, req, runtime)
2178 if _err != nil {
2179 return _result, _err
2180 }
2181 _err = dara.Convert(_body, &_result)
2182 return _result, _err
2183 }
2184
2185 // Summary:
2186 //
2187 // 创建公共DNS AppKey
2188 //
2189 // @param request - CreatePdnsAppKeyRequest
2190 //
2191 // @return CreatePdnsAppKeyResponse
2192 func CreatePdnsAppKey(client *Client, request *CreatePdnsAppKeyRequest) (_result *CreatePdnsAppKeyResponse, _err error) {
2193 runtime := &dara.RuntimeOptions{}
2194 _result = &CreatePdnsAppKeyResponse{}
2195 _body, _err := CreatePdnsAppKeyWithOptions(client,request, runtime)
2196 if _err != nil {
2197 return _result, _err
2198 }
2199 _result = _body
2200 return _result, _err
2201 }
2202
2203 // Summary:
2204 //
2205 // 创建公共DNS Udp Ip地址段
2206 //
2207 // @param request - CreatePdnsUdpIpSegmentRequest
2208 //
2209 // @param runtime - runtime options for this request RuntimeOptions
2210 //
2211 // @return CreatePdnsUdpIpSegmentResponse
2212 func CreatePdnsUdpIpSegmentWithOptions(client *Client, request *CreatePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *CreatePdnsUdpIpSegmentResponse, _err error) {
2213 if dara.BoolValue(client.EnableValidate) == true {
2214 _err = request.Validate()
2215 if _err != nil {
2216 return _result, _err
2217 }
2218 }
2219 query := map[string]interface{}{}
2220 if !dara.IsNil(request.Ip) {
2221 query["Ip"] = request.Ip
2222 }
2223
2224 if !dara.IsNil(request.IpToken) {
2225 query["IpToken"] = request.IpToken
2226 }
2227
2228 if !dara.IsNil(request.Lang) {
2229 query["Lang"] = request.Lang
2230 }
2231
2232 if !dara.IsNil(request.Name) {
2233 query["Name"] = request.Name
2234 }
2235
2236 req := &openapiutil.OpenApiRequest{
2237 Query: openapiutil.Query(query),
2238 }
2239 params := &openapiutil.Params{
2240 Action: dara.String("CreatePdnsUdpIpSegment"),
2241 Version: dara.String("2015-01-09"),
2242 Protocol: dara.String("HTTPS"),
2243 Pathname: dara.String("/"),
2244 Method: dara.String("POST"),
2245 AuthType: dara.String("AK"),
2246 Style: dara.String("RPC"),
2247 ReqBodyType: dara.String("formData"),
2248 BodyType: dara.String("json"),
2249 }
2250 _result = &CreatePdnsUdpIpSegmentResponse{}
2251 _body, _err := client.CallApi(params, req, runtime)
2252 if _err != nil {
2253 return _result, _err
2254 }
2255 _err = dara.Convert(_body, &_result)
2256 return _result, _err
2257 }
2258
2259 // Summary:
2260 //
2261 // 创建公共DNS Udp Ip地址段
2262 //
2263 // @param request - CreatePdnsUdpIpSegmentRequest
2264 //
2265 // @return CreatePdnsUdpIpSegmentResponse
2266 func CreatePdnsUdpIpSegment(client *Client, request *CreatePdnsUdpIpSegmentRequest) (_result *CreatePdnsUdpIpSegmentResponse, _err error) {
2267 runtime := &dara.RuntimeOptions{}
2268 _result = &CreatePdnsUdpIpSegmentResponse{}
2269 _body, _err := CreatePdnsUdpIpSegmentWithOptions(client,request, runtime)
2270 if _err != nil {
2271 return _result, _err
2272 }
2273 _result = _body
2274 return _result, _err
2275 }
2276
2277 // Summary:
2278 //
2279 // Deletes an address.
2280 //
2281 // @param request - DeleteCloudGtmAddressRequest
2282 //
2283 // @param runtime - runtime options for this request RuntimeOptions
2284 //
2285 // @return DeleteCloudGtmAddressResponse
2286 func DeleteCloudGtmAddressWithOptions(client *Client, request *DeleteCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmAddressResponse, _err error) {
2287 if dara.BoolValue(client.EnableValidate) == true {
2288 _err = request.Validate()
2289 if _err != nil {
2290 return _result, _err
2291 }
2292 }
2293 query := map[string]interface{}{}
2294 if !dara.IsNil(request.AcceptLanguage) {
2295 query["AcceptLanguage"] = request.AcceptLanguage
2296 }
2297
2298 if !dara.IsNil(request.AddressId) {
2299 query["AddressId"] = request.AddressId
2300 }
2301
2302 if !dara.IsNil(request.ClientToken) {
2303 query["ClientToken"] = request.ClientToken
2304 }
2305
2306 req := &openapiutil.OpenApiRequest{
2307 Query: openapiutil.Query(query),
2308 }
2309 params := &openapiutil.Params{
2310 Action: dara.String("DeleteCloudGtmAddress"),
2311 Version: dara.String("2015-01-09"),
2312 Protocol: dara.String("HTTPS"),
2313 Pathname: dara.String("/"),
2314 Method: dara.String("POST"),
2315 AuthType: dara.String("AK"),
2316 Style: dara.String("RPC"),
2317 ReqBodyType: dara.String("formData"),
2318 BodyType: dara.String("json"),
2319 }
2320 _result = &DeleteCloudGtmAddressResponse{}
2321 _body, _err := client.CallApi(params, req, runtime)
2322 if _err != nil {
2323 return _result, _err
2324 }
2325 _err = dara.Convert(_body, &_result)
2326 return _result, _err
2327 }
2328
2329 // Summary:
2330 //
2331 // Deletes an address.
2332 //
2333 // @param request - DeleteCloudGtmAddressRequest
2334 //
2335 // @return DeleteCloudGtmAddressResponse
2336 func DeleteCloudGtmAddress(client *Client, request *DeleteCloudGtmAddressRequest) (_result *DeleteCloudGtmAddressResponse, _err error) {
2337 runtime := &dara.RuntimeOptions{}
2338 _result = &DeleteCloudGtmAddressResponse{}
2339 _body, _err := DeleteCloudGtmAddressWithOptions(client,request, runtime)
2340 if _err != nil {
2341 return _result, _err
2342 }
2343 _result = _body
2344 return _result, _err
2345 }
2346
2347 // Summary:
2348 //
2349 // Deletes an address pool.
2350 //
2351 // @param request - DeleteCloudGtmAddressPoolRequest
2352 //
2353 // @param runtime - runtime options for this request RuntimeOptions
2354 //
2355 // @return DeleteCloudGtmAddressPoolResponse
2356 func DeleteCloudGtmAddressPoolWithOptions(client *Client, request *DeleteCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmAddressPoolResponse, _err error) {
2357 if dara.BoolValue(client.EnableValidate) == true {
2358 _err = request.Validate()
2359 if _err != nil {
2360 return _result, _err
2361 }
2362 }
2363 query := map[string]interface{}{}
2364 if !dara.IsNil(request.AcceptLanguage) {
2365 query["AcceptLanguage"] = request.AcceptLanguage
2366 }
2367
2368 if !dara.IsNil(request.AddressPoolId) {
2369 query["AddressPoolId"] = request.AddressPoolId
2370 }
2371
2372 if !dara.IsNil(request.ClientToken) {
2373 query["ClientToken"] = request.ClientToken
2374 }
2375
2376 req := &openapiutil.OpenApiRequest{
2377 Query: openapiutil.Query(query),
2378 }
2379 params := &openapiutil.Params{
2380 Action: dara.String("DeleteCloudGtmAddressPool"),
2381 Version: dara.String("2015-01-09"),
2382 Protocol: dara.String("HTTPS"),
2383 Pathname: dara.String("/"),
2384 Method: dara.String("POST"),
2385 AuthType: dara.String("AK"),
2386 Style: dara.String("RPC"),
2387 ReqBodyType: dara.String("formData"),
2388 BodyType: dara.String("json"),
2389 }
2390 _result = &DeleteCloudGtmAddressPoolResponse{}
2391 _body, _err := client.CallApi(params, req, runtime)
2392 if _err != nil {
2393 return _result, _err
2394 }
2395 _err = dara.Convert(_body, &_result)
2396 return _result, _err
2397 }
2398
2399 // Summary:
2400 //
2401 // Deletes an address pool.
2402 //
2403 // @param request - DeleteCloudGtmAddressPoolRequest
2404 //
2405 // @return DeleteCloudGtmAddressPoolResponse
2406 func DeleteCloudGtmAddressPool(client *Client, request *DeleteCloudGtmAddressPoolRequest) (_result *DeleteCloudGtmAddressPoolResponse, _err error) {
2407 runtime := &dara.RuntimeOptions{}
2408 _result = &DeleteCloudGtmAddressPoolResponse{}
2409 _body, _err := DeleteCloudGtmAddressPoolWithOptions(client,request, runtime)
2410 if _err != nil {
2411 return _result, _err
2412 }
2413 _result = _body
2414 return _result, _err
2415 }
2416
2417 // Summary:
2418 //
2419 // Deletes an access domain name that is configured for a Global Traffic Manager (GTM) 3.0 instance.
2420 //
2421 // @param request - DeleteCloudGtmInstanceConfigRequest
2422 //
2423 // @param runtime - runtime options for this request RuntimeOptions
2424 //
2425 // @return DeleteCloudGtmInstanceConfigResponse
2426 func DeleteCloudGtmInstanceConfigWithOptions(client *Client, request *DeleteCloudGtmInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmInstanceConfigResponse, _err error) {
2427 if dara.BoolValue(client.EnableValidate) == true {
2428 _err = request.Validate()
2429 if _err != nil {
2430 return _result, _err
2431 }
2432 }
2433 query := map[string]interface{}{}
2434 if !dara.IsNil(request.AcceptLanguage) {
2435 query["AcceptLanguage"] = request.AcceptLanguage
2436 }
2437
2438 if !dara.IsNil(request.ClientToken) {
2439 query["ClientToken"] = request.ClientToken
2440 }
2441
2442 if !dara.IsNil(request.ConfigId) {
2443 query["ConfigId"] = request.ConfigId
2444 }
2445
2446 if !dara.IsNil(request.InstanceId) {
2447 query["InstanceId"] = request.InstanceId
2448 }
2449
2450 req := &openapiutil.OpenApiRequest{
2451 Query: openapiutil.Query(query),
2452 }
2453 params := &openapiutil.Params{
2454 Action: dara.String("DeleteCloudGtmInstanceConfig"),
2455 Version: dara.String("2015-01-09"),
2456 Protocol: dara.String("HTTPS"),
2457 Pathname: dara.String("/"),
2458 Method: dara.String("POST"),
2459 AuthType: dara.String("AK"),
2460 Style: dara.String("RPC"),
2461 ReqBodyType: dara.String("formData"),
2462 BodyType: dara.String("json"),
2463 }
2464 _result = &DeleteCloudGtmInstanceConfigResponse{}
2465 _body, _err := client.CallApi(params, req, runtime)
2466 if _err != nil {
2467 return _result, _err
2468 }
2469 _err = dara.Convert(_body, &_result)
2470 return _result, _err
2471 }
2472
2473 // Summary:
2474 //
2475 // Deletes an access domain name that is configured for a Global Traffic Manager (GTM) 3.0 instance.
2476 //
2477 // @param request - DeleteCloudGtmInstanceConfigRequest
2478 //
2479 // @return DeleteCloudGtmInstanceConfigResponse
2480 func DeleteCloudGtmInstanceConfig(client *Client, request *DeleteCloudGtmInstanceConfigRequest) (_result *DeleteCloudGtmInstanceConfigResponse, _err error) {
2481 runtime := &dara.RuntimeOptions{}
2482 _result = &DeleteCloudGtmInstanceConfigResponse{}
2483 _body, _err := DeleteCloudGtmInstanceConfigWithOptions(client,request, runtime)
2484 if _err != nil {
2485 return _result, _err
2486 }
2487 _result = _body
2488 return _result, _err
2489 }
2490
2491 // Summary:
2492 //
2493 // Deletes a health check template.
2494 //
2495 // @param request - DeleteCloudGtmMonitorTemplateRequest
2496 //
2497 // @param runtime - runtime options for this request RuntimeOptions
2498 //
2499 // @return DeleteCloudGtmMonitorTemplateResponse
2500 func DeleteCloudGtmMonitorTemplateWithOptions(client *Client, request *DeleteCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmMonitorTemplateResponse, _err error) {
2501 if dara.BoolValue(client.EnableValidate) == true {
2502 _err = request.Validate()
2503 if _err != nil {
2504 return _result, _err
2505 }
2506 }
2507 query := map[string]interface{}{}
2508 if !dara.IsNil(request.AcceptLanguage) {
2509 query["AcceptLanguage"] = request.AcceptLanguage
2510 }
2511
2512 if !dara.IsNil(request.ClientToken) {
2513 query["ClientToken"] = request.ClientToken
2514 }
2515
2516 if !dara.IsNil(request.TemplateId) {
2517 query["TemplateId"] = request.TemplateId
2518 }
2519
2520 req := &openapiutil.OpenApiRequest{
2521 Query: openapiutil.Query(query),
2522 }
2523 params := &openapiutil.Params{
2524 Action: dara.String("DeleteCloudGtmMonitorTemplate"),
2525 Version: dara.String("2015-01-09"),
2526 Protocol: dara.String("HTTPS"),
2527 Pathname: dara.String("/"),
2528 Method: dara.String("POST"),
2529 AuthType: dara.String("AK"),
2530 Style: dara.String("RPC"),
2531 ReqBodyType: dara.String("formData"),
2532 BodyType: dara.String("json"),
2533 }
2534 _result = &DeleteCloudGtmMonitorTemplateResponse{}
2535 _body, _err := client.CallApi(params, req, runtime)
2536 if _err != nil {
2537 return _result, _err
2538 }
2539 _err = dara.Convert(_body, &_result)
2540 return _result, _err
2541 }
2542
2543 // Summary:
2544 //
2545 // Deletes a health check template.
2546 //
2547 // @param request - DeleteCloudGtmMonitorTemplateRequest
2548 //
2549 // @return DeleteCloudGtmMonitorTemplateResponse
2550 func DeleteCloudGtmMonitorTemplate(client *Client, request *DeleteCloudGtmMonitorTemplateRequest) (_result *DeleteCloudGtmMonitorTemplateResponse, _err error) {
2551 runtime := &dara.RuntimeOptions{}
2552 _result = &DeleteCloudGtmMonitorTemplateResponse{}
2553 _body, _err := DeleteCloudGtmMonitorTemplateWithOptions(client,request, runtime)
2554 if _err != nil {
2555 return _result, _err
2556 }
2557 _result = _body
2558 return _result, _err
2559 }
2560
2561 // Summary:
2562 //
2563 // Deletes custom lines at a time by using the unique IDs.
2564 //
2565 // @param request - DeleteCustomLinesRequest
2566 //
2567 // @param runtime - runtime options for this request RuntimeOptions
2568 //
2569 // @return DeleteCustomLinesResponse
2570 func DeleteCustomLinesWithOptions(client *Client, request *DeleteCustomLinesRequest, runtime *dara.RuntimeOptions) (_result *DeleteCustomLinesResponse, _err error) {
2571 if dara.BoolValue(client.EnableValidate) == true {
2572 _err = request.Validate()
2573 if _err != nil {
2574 return _result, _err
2575 }
2576 }
2577 query := map[string]interface{}{}
2578 if !dara.IsNil(request.Lang) {
2579 query["Lang"] = request.Lang
2580 }
2581
2582 if !dara.IsNil(request.LineIds) {
2583 query["LineIds"] = request.LineIds
2584 }
2585
2586 req := &openapiutil.OpenApiRequest{
2587 Query: openapiutil.Query(query),
2588 }
2589 params := &openapiutil.Params{
2590 Action: dara.String("DeleteCustomLines"),
2591 Version: dara.String("2015-01-09"),
2592 Protocol: dara.String("HTTPS"),
2593 Pathname: dara.String("/"),
2594 Method: dara.String("POST"),
2595 AuthType: dara.String("AK"),
2596 Style: dara.String("RPC"),
2597 ReqBodyType: dara.String("formData"),
2598 BodyType: dara.String("json"),
2599 }
2600 _result = &DeleteCustomLinesResponse{}
2601 _body, _err := client.CallApi(params, req, runtime)
2602 if _err != nil {
2603 return _result, _err
2604 }
2605 _err = dara.Convert(_body, &_result)
2606 return _result, _err
2607 }
2608
2609 // Summary:
2610 //
2611 // Deletes custom lines at a time by using the unique IDs.
2612 //
2613 // @param request - DeleteCustomLinesRequest
2614 //
2615 // @return DeleteCustomLinesResponse
2616 func DeleteCustomLines(client *Client, request *DeleteCustomLinesRequest) (_result *DeleteCustomLinesResponse, _err error) {
2617 runtime := &dara.RuntimeOptions{}
2618 _result = &DeleteCustomLinesResponse{}
2619 _body, _err := DeleteCustomLinesWithOptions(client,request, runtime)
2620 if _err != nil {
2621 return _result, _err
2622 }
2623 _result = _body
2624 return _result, _err
2625 }
2626
2627 // Summary:
2628 //
2629 // Deletes a specified cache-accelerated domain name.
2630 //
2631 // @param request - DeleteDnsCacheDomainRequest
2632 //
2633 // @param runtime - runtime options for this request RuntimeOptions
2634 //
2635 // @return DeleteDnsCacheDomainResponse
2636 func DeleteDnsCacheDomainWithOptions(client *Client, request *DeleteDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsCacheDomainResponse, _err error) {
2637 if dara.BoolValue(client.EnableValidate) == true {
2638 _err = request.Validate()
2639 if _err != nil {
2640 return _result, _err
2641 }
2642 }
2643 query := map[string]interface{}{}
2644 if !dara.IsNil(request.DomainName) {
2645 query["DomainName"] = request.DomainName
2646 }
2647
2648 if !dara.IsNil(request.Lang) {
2649 query["Lang"] = request.Lang
2650 }
2651
2652 req := &openapiutil.OpenApiRequest{
2653 Query: openapiutil.Query(query),
2654 }
2655 params := &openapiutil.Params{
2656 Action: dara.String("DeleteDnsCacheDomain"),
2657 Version: dara.String("2015-01-09"),
2658 Protocol: dara.String("HTTPS"),
2659 Pathname: dara.String("/"),
2660 Method: dara.String("POST"),
2661 AuthType: dara.String("AK"),
2662 Style: dara.String("RPC"),
2663 ReqBodyType: dara.String("formData"),
2664 BodyType: dara.String("json"),
2665 }
2666 _result = &DeleteDnsCacheDomainResponse{}
2667 _body, _err := client.CallApi(params, req, runtime)
2668 if _err != nil {
2669 return _result, _err
2670 }
2671 _err = dara.Convert(_body, &_result)
2672 return _result, _err
2673 }
2674
2675 // Summary:
2676 //
2677 // Deletes a specified cache-accelerated domain name.
2678 //
2679 // @param request - DeleteDnsCacheDomainRequest
2680 //
2681 // @return DeleteDnsCacheDomainResponse
2682 func DeleteDnsCacheDomain(client *Client, request *DeleteDnsCacheDomainRequest) (_result *DeleteDnsCacheDomainResponse, _err error) {
2683 runtime := &dara.RuntimeOptions{}
2684 _result = &DeleteDnsCacheDomainResponse{}
2685 _body, _err := DeleteDnsCacheDomainWithOptions(client,request, runtime)
2686 if _err != nil {
2687 return _result, _err
2688 }
2689 _result = _body
2690 return _result, _err
2691 }
2692
2693 // @param request - DeleteDnsGtmAccessStrategyRequest
2694 //
2695 // @param runtime - runtime options for this request RuntimeOptions
2696 //
2697 // @return DeleteDnsGtmAccessStrategyResponse
2698 func DeleteDnsGtmAccessStrategyWithOptions(client *Client, request *DeleteDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsGtmAccessStrategyResponse, _err error) {
2699 if dara.BoolValue(client.EnableValidate) == true {
2700 _err = request.Validate()
2701 if _err != nil {
2702 return _result, _err
2703 }
2704 }
2705 query := map[string]interface{}{}
2706 if !dara.IsNil(request.Lang) {
2707 query["Lang"] = request.Lang
2708 }
2709
2710 if !dara.IsNil(request.StrategyId) {
2711 query["StrategyId"] = request.StrategyId
2712 }
2713
2714 req := &openapiutil.OpenApiRequest{
2715 Query: openapiutil.Query(query),
2716 }
2717 params := &openapiutil.Params{
2718 Action: dara.String("DeleteDnsGtmAccessStrategy"),
2719 Version: dara.String("2015-01-09"),
2720 Protocol: dara.String("HTTPS"),
2721 Pathname: dara.String("/"),
2722 Method: dara.String("POST"),
2723 AuthType: dara.String("AK"),
2724 Style: dara.String("RPC"),
2725 ReqBodyType: dara.String("formData"),
2726 BodyType: dara.String("json"),
2727 }
2728 _result = &DeleteDnsGtmAccessStrategyResponse{}
2729 _body, _err := client.CallApi(params, req, runtime)
2730 if _err != nil {
2731 return _result, _err
2732 }
2733 _err = dara.Convert(_body, &_result)
2734 return _result, _err
2735 }
2736
2737 // @param request - DeleteDnsGtmAccessStrategyRequest
2738 //
2739 // @return DeleteDnsGtmAccessStrategyResponse
2740 func DeleteDnsGtmAccessStrategy(client *Client, request *DeleteDnsGtmAccessStrategyRequest) (_result *DeleteDnsGtmAccessStrategyResponse, _err error) {
2741 runtime := &dara.RuntimeOptions{}
2742 _result = &DeleteDnsGtmAccessStrategyResponse{}
2743 _body, _err := DeleteDnsGtmAccessStrategyWithOptions(client,request, runtime)
2744 if _err != nil {
2745 return _result, _err
2746 }
2747 _result = _body
2748 return _result, _err
2749 }
2750
2751 // @param request - DeleteDnsGtmAddressPoolRequest
2752 //
2753 // @param runtime - runtime options for this request RuntimeOptions
2754 //
2755 // @return DeleteDnsGtmAddressPoolResponse
2756 func DeleteDnsGtmAddressPoolWithOptions(client *Client, request *DeleteDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsGtmAddressPoolResponse, _err error) {
2757 if dara.BoolValue(client.EnableValidate) == true {
2758 _err = request.Validate()
2759 if _err != nil {
2760 return _result, _err
2761 }
2762 }
2763 query := map[string]interface{}{}
2764 if !dara.IsNil(request.AddrPoolId) {
2765 query["AddrPoolId"] = request.AddrPoolId
2766 }
2767
2768 if !dara.IsNil(request.Lang) {
2769 query["Lang"] = request.Lang
2770 }
2771
2772 req := &openapiutil.OpenApiRequest{
2773 Query: openapiutil.Query(query),
2774 }
2775 params := &openapiutil.Params{
2776 Action: dara.String("DeleteDnsGtmAddressPool"),
2777 Version: dara.String("2015-01-09"),
2778 Protocol: dara.String("HTTPS"),
2779 Pathname: dara.String("/"),
2780 Method: dara.String("POST"),
2781 AuthType: dara.String("AK"),
2782 Style: dara.String("RPC"),
2783 ReqBodyType: dara.String("formData"),
2784 BodyType: dara.String("json"),
2785 }
2786 _result = &DeleteDnsGtmAddressPoolResponse{}
2787 _body, _err := client.CallApi(params, req, runtime)
2788 if _err != nil {
2789 return _result, _err
2790 }
2791 _err = dara.Convert(_body, &_result)
2792 return _result, _err
2793 }
2794
2795 // @param request - DeleteDnsGtmAddressPoolRequest
2796 //
2797 // @return DeleteDnsGtmAddressPoolResponse
2798 func DeleteDnsGtmAddressPool(client *Client, request *DeleteDnsGtmAddressPoolRequest) (_result *DeleteDnsGtmAddressPoolResponse, _err error) {
2799 runtime := &dara.RuntimeOptions{}
2800 _result = &DeleteDnsGtmAddressPoolResponse{}
2801 _body, _err := DeleteDnsGtmAddressPoolWithOptions(client,request, runtime)
2802 if _err != nil {
2803 return _result, _err
2804 }
2805 _result = _body
2806 return _result, _err
2807 }
2808
2809 // Summary:
2810 //
2811 // Deletes a domain name based on the specified parameters.
2812 //
2813 // @param request - DeleteDomainRequest
2814 //
2815 // @param runtime - runtime options for this request RuntimeOptions
2816 //
2817 // @return DeleteDomainResponse
2818 func DeleteDomainWithOptions(client *Client, request *DeleteDomainRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainResponse, _err error) {
2819 if dara.BoolValue(client.EnableValidate) == true {
2820 _err = request.Validate()
2821 if _err != nil {
2822 return _result, _err
2823 }
2824 }
2825 query := map[string]interface{}{}
2826 if !dara.IsNil(request.DomainName) {
2827 query["DomainName"] = request.DomainName
2828 }
2829
2830 if !dara.IsNil(request.Lang) {
2831 query["Lang"] = request.Lang
2832 }
2833
2834 req := &openapiutil.OpenApiRequest{
2835 Query: openapiutil.Query(query),
2836 }
2837 params := &openapiutil.Params{
2838 Action: dara.String("DeleteDomain"),
2839 Version: dara.String("2015-01-09"),
2840 Protocol: dara.String("HTTPS"),
2841 Pathname: dara.String("/"),
2842 Method: dara.String("POST"),
2843 AuthType: dara.String("AK"),
2844 Style: dara.String("RPC"),
2845 ReqBodyType: dara.String("formData"),
2846 BodyType: dara.String("json"),
2847 }
2848 _result = &DeleteDomainResponse{}
2849 _body, _err := client.CallApi(params, req, runtime)
2850 if _err != nil {
2851 return _result, _err
2852 }
2853 _err = dara.Convert(_body, &_result)
2854 return _result, _err
2855 }
2856
2857 // Summary:
2858 //
2859 // Deletes a domain name based on the specified parameters.
2860 //
2861 // @param request - DeleteDomainRequest
2862 //
2863 // @return DeleteDomainResponse
2864 func DeleteDomain(client *Client, request *DeleteDomainRequest) (_result *DeleteDomainResponse, _err error) {
2865 runtime := &dara.RuntimeOptions{}
2866 _result = &DeleteDomainResponse{}
2867 _body, _err := DeleteDomainWithOptions(client,request, runtime)
2868 if _err != nil {
2869 return _result, _err
2870 }
2871 _result = _body
2872 return _result, _err
2873 }
2874
2875 // Summary:
2876 //
2877 // Deletes a domain name group. After you delete the domain name group, the domain names in the group are moved to the default group.
2878 //
2879 // Description:
2880 //
2881 // > The default group cannot be deleted.
2882 //
2883 // @param request - DeleteDomainGroupRequest
2884 //
2885 // @param runtime - runtime options for this request RuntimeOptions
2886 //
2887 // @return DeleteDomainGroupResponse
2888 func DeleteDomainGroupWithOptions(client *Client, request *DeleteDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainGroupResponse, _err error) {
2889 if dara.BoolValue(client.EnableValidate) == true {
2890 _err = request.Validate()
2891 if _err != nil {
2892 return _result, _err
2893 }
2894 }
2895 query := map[string]interface{}{}
2896 if !dara.IsNil(request.GroupId) {
2897 query["GroupId"] = request.GroupId
2898 }
2899
2900 if !dara.IsNil(request.Lang) {
2901 query["Lang"] = request.Lang
2902 }
2903
2904 req := &openapiutil.OpenApiRequest{
2905 Query: openapiutil.Query(query),
2906 }
2907 params := &openapiutil.Params{
2908 Action: dara.String("DeleteDomainGroup"),
2909 Version: dara.String("2015-01-09"),
2910 Protocol: dara.String("HTTPS"),
2911 Pathname: dara.String("/"),
2912 Method: dara.String("POST"),
2913 AuthType: dara.String("AK"),
2914 Style: dara.String("RPC"),
2915 ReqBodyType: dara.String("formData"),
2916 BodyType: dara.String("json"),
2917 }
2918 _result = &DeleteDomainGroupResponse{}
2919 _body, _err := client.CallApi(params, req, runtime)
2920 if _err != nil {
2921 return _result, _err
2922 }
2923 _err = dara.Convert(_body, &_result)
2924 return _result, _err
2925 }
2926
2927 // Summary:
2928 //
2929 // Deletes a domain name group. After you delete the domain name group, the domain names in the group are moved to the default group.
2930 //
2931 // Description:
2932 //
2933 // > The default group cannot be deleted.
2934 //
2935 // @param request - DeleteDomainGroupRequest
2936 //
2937 // @return DeleteDomainGroupResponse
2938 func DeleteDomainGroup(client *Client, request *DeleteDomainGroupRequest) (_result *DeleteDomainGroupResponse, _err error) {
2939 runtime := &dara.RuntimeOptions{}
2940 _result = &DeleteDomainGroupResponse{}
2941 _body, _err := DeleteDomainGroupWithOptions(client,request, runtime)
2942 if _err != nil {
2943 return _result, _err
2944 }
2945 _result = _body
2946 return _result, _err
2947 }
2948
2949 // Summary:
2950 //
2951 // Deletes an Alibaba Cloud DNS (DNS) record based on the specified parameters.
2952 //
2953 // @param request - DeleteDomainRecordRequest
2954 //
2955 // @param runtime - runtime options for this request RuntimeOptions
2956 //
2957 // @return DeleteDomainRecordResponse
2958 func DeleteDomainRecordWithOptions(client *Client, request *DeleteDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainRecordResponse, _err error) {
2959 if dara.BoolValue(client.EnableValidate) == true {
2960 _err = request.Validate()
2961 if _err != nil {
2962 return _result, _err
2963 }
2964 }
2965 query := map[string]interface{}{}
2966 if !dara.IsNil(request.Lang) {
2967 query["Lang"] = request.Lang
2968 }
2969
2970 if !dara.IsNil(request.RecordId) {
2971 query["RecordId"] = request.RecordId
2972 }
2973
2974 if !dara.IsNil(request.UserClientIp) {
2975 query["UserClientIp"] = request.UserClientIp
2976 }
2977
2978 req := &openapiutil.OpenApiRequest{
2979 Query: openapiutil.Query(query),
2980 }
2981 params := &openapiutil.Params{
2982 Action: dara.String("DeleteDomainRecord"),
2983 Version: dara.String("2015-01-09"),
2984 Protocol: dara.String("HTTPS"),
2985 Pathname: dara.String("/"),
2986 Method: dara.String("POST"),
2987 AuthType: dara.String("AK"),
2988 Style: dara.String("RPC"),
2989 ReqBodyType: dara.String("formData"),
2990 BodyType: dara.String("json"),
2991 }
2992 _result = &DeleteDomainRecordResponse{}
2993 _body, _err := client.CallApi(params, req, runtime)
2994 if _err != nil {
2995 return _result, _err
2996 }
2997 _err = dara.Convert(_body, &_result)
2998 return _result, _err
2999 }
3000
3001 // Summary:
3002 //
3003 // Deletes an Alibaba Cloud DNS (DNS) record based on the specified parameters.
3004 //
3005 // @param request - DeleteDomainRecordRequest
3006 //
3007 // @return DeleteDomainRecordResponse
3008 func DeleteDomainRecord(client *Client, request *DeleteDomainRecordRequest) (_result *DeleteDomainRecordResponse, _err error) {
3009 runtime := &dara.RuntimeOptions{}
3010 _result = &DeleteDomainRecordResponse{}
3011 _body, _err := DeleteDomainRecordWithOptions(client,request, runtime)
3012 if _err != nil {
3013 return _result, _err
3014 }
3015 _result = _body
3016 return _result, _err
3017 }
3018
3019 // @param request - DeleteGtmAccessStrategyRequest
3020 //
3021 // @param runtime - runtime options for this request RuntimeOptions
3022 //
3023 // @return DeleteGtmAccessStrategyResponse
3024 func DeleteGtmAccessStrategyWithOptions(client *Client, request *DeleteGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmAccessStrategyResponse, _err error) {
3025 if dara.BoolValue(client.EnableValidate) == true {
3026 _err = request.Validate()
3027 if _err != nil {
3028 return _result, _err
3029 }
3030 }
3031 query := map[string]interface{}{}
3032 if !dara.IsNil(request.Lang) {
3033 query["Lang"] = request.Lang
3034 }
3035
3036 if !dara.IsNil(request.StrategyId) {
3037 query["StrategyId"] = request.StrategyId
3038 }
3039
3040 req := &openapiutil.OpenApiRequest{
3041 Query: openapiutil.Query(query),
3042 }
3043 params := &openapiutil.Params{
3044 Action: dara.String("DeleteGtmAccessStrategy"),
3045 Version: dara.String("2015-01-09"),
3046 Protocol: dara.String("HTTPS"),
3047 Pathname: dara.String("/"),
3048 Method: dara.String("POST"),
3049 AuthType: dara.String("AK"),
3050 Style: dara.String("RPC"),
3051 ReqBodyType: dara.String("formData"),
3052 BodyType: dara.String("json"),
3053 }
3054 _result = &DeleteGtmAccessStrategyResponse{}
3055 _body, _err := client.CallApi(params, req, runtime)
3056 if _err != nil {
3057 return _result, _err
3058 }
3059 _err = dara.Convert(_body, &_result)
3060 return _result, _err
3061 }
3062
3063 // @param request - DeleteGtmAccessStrategyRequest
3064 //
3065 // @return DeleteGtmAccessStrategyResponse
3066 func DeleteGtmAccessStrategy(client *Client, request *DeleteGtmAccessStrategyRequest) (_result *DeleteGtmAccessStrategyResponse, _err error) {
3067 runtime := &dara.RuntimeOptions{}
3068 _result = &DeleteGtmAccessStrategyResponse{}
3069 _body, _err := DeleteGtmAccessStrategyWithOptions(client,request, runtime)
3070 if _err != nil {
3071 return _result, _err
3072 }
3073 _result = _body
3074 return _result, _err
3075 }
3076
3077 // @param request - DeleteGtmAddressPoolRequest
3078 //
3079 // @param runtime - runtime options for this request RuntimeOptions
3080 //
3081 // @return DeleteGtmAddressPoolResponse
3082 func DeleteGtmAddressPoolWithOptions(client *Client, request *DeleteGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmAddressPoolResponse, _err error) {
3083 if dara.BoolValue(client.EnableValidate) == true {
3084 _err = request.Validate()
3085 if _err != nil {
3086 return _result, _err
3087 }
3088 }
3089 query := map[string]interface{}{}
3090 if !dara.IsNil(request.AddrPoolId) {
3091 query["AddrPoolId"] = request.AddrPoolId
3092 }
3093
3094 if !dara.IsNil(request.Lang) {
3095 query["Lang"] = request.Lang
3096 }
3097
3098 req := &openapiutil.OpenApiRequest{
3099 Query: openapiutil.Query(query),
3100 }
3101 params := &openapiutil.Params{
3102 Action: dara.String("DeleteGtmAddressPool"),
3103 Version: dara.String("2015-01-09"),
3104 Protocol: dara.String("HTTPS"),
3105 Pathname: dara.String("/"),
3106 Method: dara.String("POST"),
3107 AuthType: dara.String("AK"),
3108 Style: dara.String("RPC"),
3109 ReqBodyType: dara.String("formData"),
3110 BodyType: dara.String("json"),
3111 }
3112 _result = &DeleteGtmAddressPoolResponse{}
3113 _body, _err := client.CallApi(params, req, runtime)
3114 if _err != nil {
3115 return _result, _err
3116 }
3117 _err = dara.Convert(_body, &_result)
3118 return _result, _err
3119 }
3120
3121 // @param request - DeleteGtmAddressPoolRequest
3122 //
3123 // @return DeleteGtmAddressPoolResponse
3124 func DeleteGtmAddressPool(client *Client, request *DeleteGtmAddressPoolRequest) (_result *DeleteGtmAddressPoolResponse, _err error) {
3125 runtime := &dara.RuntimeOptions{}
3126 _result = &DeleteGtmAddressPoolResponse{}
3127 _body, _err := DeleteGtmAddressPoolWithOptions(client,request, runtime)
3128 if _err != nil {
3129 return _result, _err
3130 }
3131 _result = _body
3132 return _result, _err
3133 }
3134
3135 // @param request - DeleteGtmRecoveryPlanRequest
3136 //
3137 // @param runtime - runtime options for this request RuntimeOptions
3138 //
3139 // @return DeleteGtmRecoveryPlanResponse
3140 func DeleteGtmRecoveryPlanWithOptions(client *Client, request *DeleteGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmRecoveryPlanResponse, _err error) {
3141 if dara.BoolValue(client.EnableValidate) == true {
3142 _err = request.Validate()
3143 if _err != nil {
3144 return _result, _err
3145 }
3146 }
3147 query := map[string]interface{}{}
3148 if !dara.IsNil(request.Lang) {
3149 query["Lang"] = request.Lang
3150 }
3151
3152 if !dara.IsNil(request.RecoveryPlanId) {
3153 query["RecoveryPlanId"] = request.RecoveryPlanId
3154 }
3155
3156 req := &openapiutil.OpenApiRequest{
3157 Query: openapiutil.Query(query),
3158 }
3159 params := &openapiutil.Params{
3160 Action: dara.String("DeleteGtmRecoveryPlan"),
3161 Version: dara.String("2015-01-09"),
3162 Protocol: dara.String("HTTPS"),
3163 Pathname: dara.String("/"),
3164 Method: dara.String("POST"),
3165 AuthType: dara.String("AK"),
3166 Style: dara.String("RPC"),
3167 ReqBodyType: dara.String("formData"),
3168 BodyType: dara.String("json"),
3169 }
3170 _result = &DeleteGtmRecoveryPlanResponse{}
3171 _body, _err := client.CallApi(params, req, runtime)
3172 if _err != nil {
3173 return _result, _err
3174 }
3175 _err = dara.Convert(_body, &_result)
3176 return _result, _err
3177 }
3178
3179 // @param request - DeleteGtmRecoveryPlanRequest
3180 //
3181 // @return DeleteGtmRecoveryPlanResponse
3182 func DeleteGtmRecoveryPlan(client *Client, request *DeleteGtmRecoveryPlanRequest) (_result *DeleteGtmRecoveryPlanResponse, _err error) {
3183 runtime := &dara.RuntimeOptions{}
3184 _result = &DeleteGtmRecoveryPlanResponse{}
3185 _body, _err := DeleteGtmRecoveryPlanWithOptions(client,request, runtime)
3186 if _err != nil {
3187 return _result, _err
3188 }
3189 _result = _body
3190 return _result, _err
3191 }
3192
3193 // Summary:
3194 //
3195 // 删除递归解析内置权威解析记录
3196 //
3197 // @param request - DeleteRecursionRecordRequest
3198 //
3199 // @param runtime - runtime options for this request RuntimeOptions
3200 //
3201 // @return DeleteRecursionRecordResponse
3202 func DeleteRecursionRecordWithOptions(client *Client, request *DeleteRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecursionRecordResponse, _err error) {
3203 if dara.BoolValue(client.EnableValidate) == true {
3204 _err = request.Validate()
3205 if _err != nil {
3206 return _result, _err
3207 }
3208 }
3209 query := map[string]interface{}{}
3210 if !dara.IsNil(request.ClientToken) {
3211 query["ClientToken"] = request.ClientToken
3212 }
3213
3214 if !dara.IsNil(request.RecordId) {
3215 query["RecordId"] = request.RecordId
3216 }
3217
3218 req := &openapiutil.OpenApiRequest{
3219 Query: openapiutil.Query(query),
3220 }
3221 params := &openapiutil.Params{
3222 Action: dara.String("DeleteRecursionRecord"),
3223 Version: dara.String("2015-01-09"),
3224 Protocol: dara.String("HTTPS"),
3225 Pathname: dara.String("/"),
3226 Method: dara.String("POST"),
3227 AuthType: dara.String("AK"),
3228 Style: dara.String("RPC"),
3229 ReqBodyType: dara.String("formData"),
3230 BodyType: dara.String("json"),
3231 }
3232 _result = &DeleteRecursionRecordResponse{}
3233 _body, _err := client.CallApi(params, req, runtime)
3234 if _err != nil {
3235 return _result, _err
3236 }
3237 _err = dara.Convert(_body, &_result)
3238 return _result, _err
3239 }
3240
3241 // Summary:
3242 //
3243 // 删除递归解析内置权威解析记录
3244 //
3245 // @param request - DeleteRecursionRecordRequest
3246 //
3247 // @return DeleteRecursionRecordResponse
3248 func DeleteRecursionRecord(client *Client, request *DeleteRecursionRecordRequest) (_result *DeleteRecursionRecordResponse, _err error) {
3249 runtime := &dara.RuntimeOptions{}
3250 _result = &DeleteRecursionRecordResponse{}
3251 _body, _err := DeleteRecursionRecordWithOptions(client,request, runtime)
3252 if _err != nil {
3253 return _result, _err
3254 }
3255 _result = _body
3256 return _result, _err
3257 }
3258
3259 // Summary:
3260 //
3261 // 删除递归解析内置权威域名zone
3262 //
3263 // @param request - DeleteRecursionZoneRequest
3264 //
3265 // @param runtime - runtime options for this request RuntimeOptions
3266 //
3267 // @return DeleteRecursionZoneResponse
3268 func DeleteRecursionZoneWithOptions(client *Client, request *DeleteRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecursionZoneResponse, _err error) {
3269 if dara.BoolValue(client.EnableValidate) == true {
3270 _err = request.Validate()
3271 if _err != nil {
3272 return _result, _err
3273 }
3274 }
3275 query := map[string]interface{}{}
3276 if !dara.IsNil(request.ClientToken) {
3277 query["ClientToken"] = request.ClientToken
3278 }
3279
3280 if !dara.IsNil(request.ZoneId) {
3281 query["ZoneId"] = request.ZoneId
3282 }
3283
3284 req := &openapiutil.OpenApiRequest{
3285 Query: openapiutil.Query(query),
3286 }
3287 params := &openapiutil.Params{
3288 Action: dara.String("DeleteRecursionZone"),
3289 Version: dara.String("2015-01-09"),
3290 Protocol: dara.String("HTTPS"),
3291 Pathname: dara.String("/"),
3292 Method: dara.String("POST"),
3293 AuthType: dara.String("AK"),
3294 Style: dara.String("RPC"),
3295 ReqBodyType: dara.String("formData"),
3296 BodyType: dara.String("json"),
3297 }
3298 _result = &DeleteRecursionZoneResponse{}
3299 _body, _err := client.CallApi(params, req, runtime)
3300 if _err != nil {
3301 return _result, _err
3302 }
3303 _err = dara.Convert(_body, &_result)
3304 return _result, _err
3305 }
3306
3307 // Summary:
3308 //
3309 // 删除递归解析内置权威域名zone
3310 //
3311 // @param request - DeleteRecursionZoneRequest
3312 //
3313 // @return DeleteRecursionZoneResponse
3314 func DeleteRecursionZone(client *Client, request *DeleteRecursionZoneRequest) (_result *DeleteRecursionZoneResponse, _err error) {
3315 runtime := &dara.RuntimeOptions{}
3316 _result = &DeleteRecursionZoneResponse{}
3317 _body, _err := DeleteRecursionZoneWithOptions(client,request, runtime)
3318 if _err != nil {
3319 return _result, _err
3320 }
3321 _result = _body
3322 return _result, _err
3323 }
3324
3325 // Summary:
3326 //
3327 // Deletes the DNS records that are corresponding to a hostname based on the specified parameters.
3328 //
3329 // Description:
3330 //
3331 // If the DNS records to be deleted contain locked DNS records, the locked DNS records will not be deleted.
3332 //
3333 // @param request - DeleteSubDomainRecordsRequest
3334 //
3335 // @param runtime - runtime options for this request RuntimeOptions
3336 //
3337 // @return DeleteSubDomainRecordsResponse
3338 func DeleteSubDomainRecordsWithOptions(client *Client, request *DeleteSubDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DeleteSubDomainRecordsResponse, _err error) {
3339 if dara.BoolValue(client.EnableValidate) == true {
3340 _err = request.Validate()
3341 if _err != nil {
3342 return _result, _err
3343 }
3344 }
3345 query := map[string]interface{}{}
3346 if !dara.IsNil(request.DomainName) {
3347 query["DomainName"] = request.DomainName
3348 }
3349
3350 if !dara.IsNil(request.Lang) {
3351 query["Lang"] = request.Lang
3352 }
3353
3354 if !dara.IsNil(request.RR) {
3355 query["RR"] = request.RR
3356 }
3357
3358 if !dara.IsNil(request.Type) {
3359 query["Type"] = request.Type
3360 }
3361
3362 if !dara.IsNil(request.UserClientIp) {
3363 query["UserClientIp"] = request.UserClientIp
3364 }
3365
3366 req := &openapiutil.OpenApiRequest{
3367 Query: openapiutil.Query(query),
3368 }
3369 params := &openapiutil.Params{
3370 Action: dara.String("DeleteSubDomainRecords"),
3371 Version: dara.String("2015-01-09"),
3372 Protocol: dara.String("HTTPS"),
3373 Pathname: dara.String("/"),
3374 Method: dara.String("POST"),
3375 AuthType: dara.String("AK"),
3376 Style: dara.String("RPC"),
3377 ReqBodyType: dara.String("formData"),
3378 BodyType: dara.String("json"),
3379 }
3380 _result = &DeleteSubDomainRecordsResponse{}
3381 _body, _err := client.CallApi(params, req, runtime)
3382 if _err != nil {
3383 return _result, _err
3384 }
3385 _err = dara.Convert(_body, &_result)
3386 return _result, _err
3387 }
3388
3389 // Summary:
3390 //
3391 // Deletes the DNS records that are corresponding to a hostname based on the specified parameters.
3392 //
3393 // Description:
3394 //
3395 // If the DNS records to be deleted contain locked DNS records, the locked DNS records will not be deleted.
3396 //
3397 // @param request - DeleteSubDomainRecordsRequest
3398 //
3399 // @return DeleteSubDomainRecordsResponse
3400 func DeleteSubDomainRecords(client *Client, request *DeleteSubDomainRecordsRequest) (_result *DeleteSubDomainRecordsResponse, _err error) {
3401 runtime := &dara.RuntimeOptions{}
3402 _result = &DeleteSubDomainRecordsResponse{}
3403 _body, _err := DeleteSubDomainRecordsWithOptions(client,request, runtime)
3404 if _err != nil {
3405 return _result, _err
3406 }
3407 _result = _body
3408 return _result, _err
3409 }
3410
3411 // Summary:
3412 //
3413 // Queries the execution result of a batch operation task based on the task ID. If you do not specify task ID, the execution result of the last batch operation task is returned.
3414 //
3415 // @param request - DescribeBatchResultCountRequest
3416 //
3417 // @param runtime - runtime options for this request RuntimeOptions
3418 //
3419 // @return DescribeBatchResultCountResponse
3420 func DescribeBatchResultCountWithOptions(client *Client, request *DescribeBatchResultCountRequest, runtime *dara.RuntimeOptions) (_result *DescribeBatchResultCountResponse, _err error) {
3421 if dara.BoolValue(client.EnableValidate) == true {
3422 _err = request.Validate()
3423 if _err != nil {
3424 return _result, _err
3425 }
3426 }
3427 query := map[string]interface{}{}
3428 if !dara.IsNil(request.BatchType) {
3429 query["BatchType"] = request.BatchType
3430 }
3431
3432 if !dara.IsNil(request.Lang) {
3433 query["Lang"] = request.Lang
3434 }
3435
3436 if !dara.IsNil(request.TaskId) {
3437 query["TaskId"] = request.TaskId
3438 }
3439
3440 req := &openapiutil.OpenApiRequest{
3441 Query: openapiutil.Query(query),
3442 }
3443 params := &openapiutil.Params{
3444 Action: dara.String("DescribeBatchResultCount"),
3445 Version: dara.String("2015-01-09"),
3446 Protocol: dara.String("HTTPS"),
3447 Pathname: dara.String("/"),
3448 Method: dara.String("POST"),
3449 AuthType: dara.String("AK"),
3450 Style: dara.String("RPC"),
3451 ReqBodyType: dara.String("formData"),
3452 BodyType: dara.String("json"),
3453 }
3454 _result = &DescribeBatchResultCountResponse{}
3455 _body, _err := client.CallApi(params, req, runtime)
3456 if _err != nil {
3457 return _result, _err
3458 }
3459 _err = dara.Convert(_body, &_result)
3460 return _result, _err
3461 }
3462
3463 // Summary:
3464 //
3465 // Queries the execution result of a batch operation task based on the task ID. If you do not specify task ID, the execution result of the last batch operation task is returned.
3466 //
3467 // @param request - DescribeBatchResultCountRequest
3468 //
3469 // @return DescribeBatchResultCountResponse
3470 func DescribeBatchResultCount(client *Client, request *DescribeBatchResultCountRequest) (_result *DescribeBatchResultCountResponse, _err error) {
3471 runtime := &dara.RuntimeOptions{}
3472 _result = &DescribeBatchResultCountResponse{}
3473 _body, _err := DescribeBatchResultCountWithOptions(client,request, runtime)
3474 if _err != nil {
3475 return _result, _err
3476 }
3477 _result = _body
3478 return _result, _err
3479 }
3480
3481 // Summary:
3482 //
3483 // Queries the detailed results of a batch operation task.
3484 //
3485 // Description:
3486 //
3487 // Before you call this operation, make sure that the batch operation task is complete.
3488 //
3489 // @param request - DescribeBatchResultDetailRequest
3490 //
3491 // @param runtime - runtime options for this request RuntimeOptions
3492 //
3493 // @return DescribeBatchResultDetailResponse
3494 func DescribeBatchResultDetailWithOptions(client *Client, request *DescribeBatchResultDetailRequest, runtime *dara.RuntimeOptions) (_result *DescribeBatchResultDetailResponse, _err error) {
3495 if dara.BoolValue(client.EnableValidate) == true {
3496 _err = request.Validate()
3497 if _err != nil {
3498 return _result, _err
3499 }
3500 }
3501 query := map[string]interface{}{}
3502 if !dara.IsNil(request.BatchType) {
3503 query["BatchType"] = request.BatchType
3504 }
3505
3506 if !dara.IsNil(request.Lang) {
3507 query["Lang"] = request.Lang
3508 }
3509
3510 if !dara.IsNil(request.PageNumber) {
3511 query["PageNumber"] = request.PageNumber
3512 }
3513
3514 if !dara.IsNil(request.PageSize) {
3515 query["PageSize"] = request.PageSize
3516 }
3517
3518 if !dara.IsNil(request.Status) {
3519 query["Status"] = request.Status
3520 }
3521
3522 if !dara.IsNil(request.TaskId) {
3523 query["TaskId"] = request.TaskId
3524 }
3525
3526 req := &openapiutil.OpenApiRequest{
3527 Query: openapiutil.Query(query),
3528 }
3529 params := &openapiutil.Params{
3530 Action: dara.String("DescribeBatchResultDetail"),
3531 Version: dara.String("2015-01-09"),
3532 Protocol: dara.String("HTTPS"),
3533 Pathname: dara.String("/"),
3534 Method: dara.String("POST"),
3535 AuthType: dara.String("AK"),
3536 Style: dara.String("RPC"),
3537 ReqBodyType: dara.String("formData"),
3538 BodyType: dara.String("json"),
3539 }
3540 _result = &DescribeBatchResultDetailResponse{}
3541 _body, _err := client.CallApi(params, req, runtime)
3542 if _err != nil {
3543 return _result, _err
3544 }
3545 _err = dara.Convert(_body, &_result)
3546 return _result, _err
3547 }
3548
3549 // Summary:
3550 //
3551 // Queries the detailed results of a batch operation task.
3552 //
3553 // Description:
3554 //
3555 // Before you call this operation, make sure that the batch operation task is complete.
3556 //
3557 // @param request - DescribeBatchResultDetailRequest
3558 //
3559 // @return DescribeBatchResultDetailResponse
3560 func DescribeBatchResultDetail(client *Client, request *DescribeBatchResultDetailRequest) (_result *DescribeBatchResultDetailResponse, _err error) {
3561 runtime := &dara.RuntimeOptions{}
3562 _result = &DescribeBatchResultDetailResponse{}
3563 _body, _err := DescribeBatchResultDetailWithOptions(client,request, runtime)
3564 if _err != nil {
3565 return _result, _err
3566 }
3567 _result = _body
3568 return _result, _err
3569 }
3570
3571 // Summary:
3572 //
3573 // Queries the configurations of an address.
3574 //
3575 // @param request - DescribeCloudGtmAddressRequest
3576 //
3577 // @param runtime - runtime options for this request RuntimeOptions
3578 //
3579 // @return DescribeCloudGtmAddressResponse
3580 func DescribeCloudGtmAddressWithOptions(client *Client, request *DescribeCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressResponse, _err error) {
3581 if dara.BoolValue(client.EnableValidate) == true {
3582 _err = request.Validate()
3583 if _err != nil {
3584 return _result, _err
3585 }
3586 }
3587 query := map[string]interface{}{}
3588 if !dara.IsNil(request.AcceptLanguage) {
3589 query["AcceptLanguage"] = request.AcceptLanguage
3590 }
3591
3592 if !dara.IsNil(request.AddressId) {
3593 query["AddressId"] = request.AddressId
3594 }
3595
3596 if !dara.IsNil(request.ClientToken) {
3597 query["ClientToken"] = request.ClientToken
3598 }
3599
3600 req := &openapiutil.OpenApiRequest{
3601 Query: openapiutil.Query(query),
3602 }
3603 params := &openapiutil.Params{
3604 Action: dara.String("DescribeCloudGtmAddress"),
3605 Version: dara.String("2015-01-09"),
3606 Protocol: dara.String("HTTPS"),
3607 Pathname: dara.String("/"),
3608 Method: dara.String("POST"),
3609 AuthType: dara.String("AK"),
3610 Style: dara.String("RPC"),
3611 ReqBodyType: dara.String("formData"),
3612 BodyType: dara.String("json"),
3613 }
3614 _result = &DescribeCloudGtmAddressResponse{}
3615 _body, _err := client.CallApi(params, req, runtime)
3616 if _err != nil {
3617 return _result, _err
3618 }
3619 _err = dara.Convert(_body, &_result)
3620 return _result, _err
3621 }
3622
3623 // Summary:
3624 //
3625 // Queries the configurations of an address.
3626 //
3627 // @param request - DescribeCloudGtmAddressRequest
3628 //
3629 // @return DescribeCloudGtmAddressResponse
3630 func DescribeCloudGtmAddress(client *Client, request *DescribeCloudGtmAddressRequest) (_result *DescribeCloudGtmAddressResponse, _err error) {
3631 runtime := &dara.RuntimeOptions{}
3632 _result = &DescribeCloudGtmAddressResponse{}
3633 _body, _err := DescribeCloudGtmAddressWithOptions(client,request, runtime)
3634 if _err != nil {
3635 return _result, _err
3636 }
3637 _result = _body
3638 return _result, _err
3639 }
3640
3641 // Summary:
3642 //
3643 // Queries the configurations of an address pool.
3644 //
3645 // @param request - DescribeCloudGtmAddressPoolRequest
3646 //
3647 // @param runtime - runtime options for this request RuntimeOptions
3648 //
3649 // @return DescribeCloudGtmAddressPoolResponse
3650 func DescribeCloudGtmAddressPoolWithOptions(client *Client, request *DescribeCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressPoolResponse, _err error) {
3651 if dara.BoolValue(client.EnableValidate) == true {
3652 _err = request.Validate()
3653 if _err != nil {
3654 return _result, _err
3655 }
3656 }
3657 query := map[string]interface{}{}
3658 if !dara.IsNil(request.AcceptLanguage) {
3659 query["AcceptLanguage"] = request.AcceptLanguage
3660 }
3661
3662 if !dara.IsNil(request.AddressPoolId) {
3663 query["AddressPoolId"] = request.AddressPoolId
3664 }
3665
3666 if !dara.IsNil(request.ClientToken) {
3667 query["ClientToken"] = request.ClientToken
3668 }
3669
3670 req := &openapiutil.OpenApiRequest{
3671 Query: openapiutil.Query(query),
3672 }
3673 params := &openapiutil.Params{
3674 Action: dara.String("DescribeCloudGtmAddressPool"),
3675 Version: dara.String("2015-01-09"),
3676 Protocol: dara.String("HTTPS"),
3677 Pathname: dara.String("/"),
3678 Method: dara.String("POST"),
3679 AuthType: dara.String("AK"),
3680 Style: dara.String("RPC"),
3681 ReqBodyType: dara.String("formData"),
3682 BodyType: dara.String("json"),
3683 }
3684 _result = &DescribeCloudGtmAddressPoolResponse{}
3685 _body, _err := client.CallApi(params, req, runtime)
3686 if _err != nil {
3687 return _result, _err
3688 }
3689 _err = dara.Convert(_body, &_result)
3690 return _result, _err
3691 }
3692
3693 // Summary:
3694 //
3695 // Queries the configurations of an address pool.
3696 //
3697 // @param request - DescribeCloudGtmAddressPoolRequest
3698 //
3699 // @return DescribeCloudGtmAddressPoolResponse
3700 func DescribeCloudGtmAddressPool(client *Client, request *DescribeCloudGtmAddressPoolRequest) (_result *DescribeCloudGtmAddressPoolResponse, _err error) {
3701 runtime := &dara.RuntimeOptions{}
3702 _result = &DescribeCloudGtmAddressPoolResponse{}
3703 _body, _err := DescribeCloudGtmAddressPoolWithOptions(client,request, runtime)
3704 if _err != nil {
3705 return _result, _err
3706 }
3707 _result = _body
3708 return _result, _err
3709 }
3710
3711 // Summary:
3712 //
3713 // Queries the information about the access domain names that reference an address pool.
3714 //
3715 // @param request - DescribeCloudGtmAddressPoolReferenceRequest
3716 //
3717 // @param runtime - runtime options for this request RuntimeOptions
3718 //
3719 // @return DescribeCloudGtmAddressPoolReferenceResponse
3720 func DescribeCloudGtmAddressPoolReferenceWithOptions(client *Client, request *DescribeCloudGtmAddressPoolReferenceRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressPoolReferenceResponse, _err error) {
3721 if dara.BoolValue(client.EnableValidate) == true {
3722 _err = request.Validate()
3723 if _err != nil {
3724 return _result, _err
3725 }
3726 }
3727 query := map[string]interface{}{}
3728 if !dara.IsNil(request.AcceptLanguage) {
3729 query["AcceptLanguage"] = request.AcceptLanguage
3730 }
3731
3732 if !dara.IsNil(request.AddressPoolId) {
3733 query["AddressPoolId"] = request.AddressPoolId
3734 }
3735
3736 if !dara.IsNil(request.ClientToken) {
3737 query["ClientToken"] = request.ClientToken
3738 }
3739
3740 req := &openapiutil.OpenApiRequest{
3741 Query: openapiutil.Query(query),
3742 }
3743 params := &openapiutil.Params{
3744 Action: dara.String("DescribeCloudGtmAddressPoolReference"),
3745 Version: dara.String("2015-01-09"),
3746 Protocol: dara.String("HTTPS"),
3747 Pathname: dara.String("/"),
3748 Method: dara.String("POST"),
3749 AuthType: dara.String("AK"),
3750 Style: dara.String("RPC"),
3751 ReqBodyType: dara.String("formData"),
3752 BodyType: dara.String("json"),
3753 }
3754 _result = &DescribeCloudGtmAddressPoolReferenceResponse{}
3755 _body, _err := client.CallApi(params, req, runtime)
3756 if _err != nil {
3757 return _result, _err
3758 }
3759 _err = dara.Convert(_body, &_result)
3760 return _result, _err
3761 }
3762
3763 // Summary:
3764 //
3765 // Queries the information about the access domain names that reference an address pool.
3766 //
3767 // @param request - DescribeCloudGtmAddressPoolReferenceRequest
3768 //
3769 // @return DescribeCloudGtmAddressPoolReferenceResponse
3770 func DescribeCloudGtmAddressPoolReference(client *Client, request *DescribeCloudGtmAddressPoolReferenceRequest) (_result *DescribeCloudGtmAddressPoolReferenceResponse, _err error) {
3771 runtime := &dara.RuntimeOptions{}
3772 _result = &DescribeCloudGtmAddressPoolReferenceResponse{}
3773 _body, _err := DescribeCloudGtmAddressPoolReferenceWithOptions(client,request, runtime)
3774 if _err != nil {
3775 return _result, _err
3776 }
3777 _result = _body
3778 return _result, _err
3779 }
3780
3781 // Summary:
3782 //
3783 // Queries the information about the address pools and Global Traffic Manager (GTM) 3.0 instances that reference an address.
3784 //
3785 // @param request - DescribeCloudGtmAddressReferenceRequest
3786 //
3787 // @param runtime - runtime options for this request RuntimeOptions
3788 //
3789 // @return DescribeCloudGtmAddressReferenceResponse
3790 func DescribeCloudGtmAddressReferenceWithOptions(client *Client, request *DescribeCloudGtmAddressReferenceRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressReferenceResponse, _err error) {
3791 if dara.BoolValue(client.EnableValidate) == true {
3792 _err = request.Validate()
3793 if _err != nil {
3794 return _result, _err
3795 }
3796 }
3797 query := map[string]interface{}{}
3798 if !dara.IsNil(request.AcceptLanguage) {
3799 query["AcceptLanguage"] = request.AcceptLanguage
3800 }
3801
3802 if !dara.IsNil(request.AddressId) {
3803 query["AddressId"] = request.AddressId
3804 }
3805
3806 if !dara.IsNil(request.ClientToken) {
3807 query["ClientToken"] = request.ClientToken
3808 }
3809
3810 req := &openapiutil.OpenApiRequest{
3811 Query: openapiutil.Query(query),
3812 }
3813 params := &openapiutil.Params{
3814 Action: dara.String("DescribeCloudGtmAddressReference"),
3815 Version: dara.String("2015-01-09"),
3816 Protocol: dara.String("HTTPS"),
3817 Pathname: dara.String("/"),
3818 Method: dara.String("POST"),
3819 AuthType: dara.String("AK"),
3820 Style: dara.String("RPC"),
3821 ReqBodyType: dara.String("formData"),
3822 BodyType: dara.String("json"),
3823 }
3824 _result = &DescribeCloudGtmAddressReferenceResponse{}
3825 _body, _err := client.CallApi(params, req, runtime)
3826 if _err != nil {
3827 return _result, _err
3828 }
3829 _err = dara.Convert(_body, &_result)
3830 return _result, _err
3831 }
3832
3833 // Summary:
3834 //
3835 // Queries the information about the address pools and Global Traffic Manager (GTM) 3.0 instances that reference an address.
3836 //
3837 // @param request - DescribeCloudGtmAddressReferenceRequest
3838 //
3839 // @return DescribeCloudGtmAddressReferenceResponse
3840 func DescribeCloudGtmAddressReference(client *Client, request *DescribeCloudGtmAddressReferenceRequest) (_result *DescribeCloudGtmAddressReferenceResponse, _err error) {
3841 runtime := &dara.RuntimeOptions{}
3842 _result = &DescribeCloudGtmAddressReferenceResponse{}
3843 _body, _err := DescribeCloudGtmAddressReferenceWithOptions(client,request, runtime)
3844 if _err != nil {
3845 return _result, _err
3846 }
3847 _result = _body
3848 return _result, _err
3849 }
3850
3851 // @param request - DescribeCloudGtmGlobalAlertRequest
3852 //
3853 // @param runtime - runtime options for this request RuntimeOptions
3854 //
3855 // @return DescribeCloudGtmGlobalAlertResponse
3856 func DescribeCloudGtmGlobalAlertWithOptions(client *Client, request *DescribeCloudGtmGlobalAlertRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmGlobalAlertResponse, _err error) {
3857 if dara.BoolValue(client.EnableValidate) == true {
3858 _err = request.Validate()
3859 if _err != nil {
3860 return _result, _err
3861 }
3862 }
3863 query := map[string]interface{}{}
3864 if !dara.IsNil(request.AcceptLanguage) {
3865 query["AcceptLanguage"] = request.AcceptLanguage
3866 }
3867
3868 if !dara.IsNil(request.ClientToken) {
3869 query["ClientToken"] = request.ClientToken
3870 }
3871
3872 req := &openapiutil.OpenApiRequest{
3873 Query: openapiutil.Query(query),
3874 }
3875 params := &openapiutil.Params{
3876 Action: dara.String("DescribeCloudGtmGlobalAlert"),
3877 Version: dara.String("2015-01-09"),
3878 Protocol: dara.String("HTTPS"),
3879 Pathname: dara.String("/"),
3880 Method: dara.String("POST"),
3881 AuthType: dara.String("AK"),
3882 Style: dara.String("RPC"),
3883 ReqBodyType: dara.String("formData"),
3884 BodyType: dara.String("json"),
3885 }
3886 _result = &DescribeCloudGtmGlobalAlertResponse{}
3887 _body, _err := client.CallApi(params, req, runtime)
3888 if _err != nil {
3889 return _result, _err
3890 }
3891 _err = dara.Convert(_body, &_result)
3892 return _result, _err
3893 }
3894
3895 // @param request - DescribeCloudGtmGlobalAlertRequest
3896 //
3897 // @return DescribeCloudGtmGlobalAlertResponse
3898 func DescribeCloudGtmGlobalAlert(client *Client, request *DescribeCloudGtmGlobalAlertRequest) (_result *DescribeCloudGtmGlobalAlertResponse, _err error) {
3899 runtime := &dara.RuntimeOptions{}
3900 _result = &DescribeCloudGtmGlobalAlertResponse{}
3901 _body, _err := DescribeCloudGtmGlobalAlertWithOptions(client,request, runtime)
3902 if _err != nil {
3903 return _result, _err
3904 }
3905 _result = _body
3906 return _result, _err
3907 }
3908
3909 // @param request - DescribeCloudGtmInstanceConfigAlertRequest
3910 //
3911 // @param runtime - runtime options for this request RuntimeOptions
3912 //
3913 // @return DescribeCloudGtmInstanceConfigAlertResponse
3914 func DescribeCloudGtmInstanceConfigAlertWithOptions(client *Client, request *DescribeCloudGtmInstanceConfigAlertRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmInstanceConfigAlertResponse, _err error) {
3915 if dara.BoolValue(client.EnableValidate) == true {
3916 _err = request.Validate()
3917 if _err != nil {
3918 return _result, _err
3919 }
3920 }
3921 query := map[string]interface{}{}
3922 if !dara.IsNil(request.AcceptLanguage) {
3923 query["AcceptLanguage"] = request.AcceptLanguage
3924 }
3925
3926 if !dara.IsNil(request.ClientToken) {
3927 query["ClientToken"] = request.ClientToken
3928 }
3929
3930 if !dara.IsNil(request.ConfigId) {
3931 query["ConfigId"] = request.ConfigId
3932 }
3933
3934 if !dara.IsNil(request.InstanceId) {
3935 query["InstanceId"] = request.InstanceId
3936 }
3937
3938 req := &openapiutil.OpenApiRequest{
3939 Query: openapiutil.Query(query),
3940 }
3941 params := &openapiutil.Params{
3942 Action: dara.String("DescribeCloudGtmInstanceConfigAlert"),
3943 Version: dara.String("2015-01-09"),
3944 Protocol: dara.String("HTTPS"),
3945 Pathname: dara.String("/"),
3946 Method: dara.String("POST"),
3947 AuthType: dara.String("AK"),
3948 Style: dara.String("RPC"),
3949 ReqBodyType: dara.String("formData"),
3950 BodyType: dara.String("json"),
3951 }
3952 _result = &DescribeCloudGtmInstanceConfigAlertResponse{}
3953 _body, _err := client.CallApi(params, req, runtime)
3954 if _err != nil {
3955 return _result, _err
3956 }
3957 _err = dara.Convert(_body, &_result)
3958 return _result, _err
3959 }
3960
3961 // @param request - DescribeCloudGtmInstanceConfigAlertRequest
3962 //
3963 // @return DescribeCloudGtmInstanceConfigAlertResponse
3964 func DescribeCloudGtmInstanceConfigAlert(client *Client, request *DescribeCloudGtmInstanceConfigAlertRequest) (_result *DescribeCloudGtmInstanceConfigAlertResponse, _err error) {
3965 runtime := &dara.RuntimeOptions{}
3966 _result = &DescribeCloudGtmInstanceConfigAlertResponse{}
3967 _body, _err := DescribeCloudGtmInstanceConfigAlertWithOptions(client,request, runtime)
3968 if _err != nil {
3969 return _result, _err
3970 }
3971 _result = _body
3972 return _result, _err
3973 }
3974
3975 // Summary:
3976 //
3977 // Queries the complete configuration information about a Global Traffic Manager (GTM) instance.
3978 //
3979 // @param request - DescribeCloudGtmInstanceConfigFullInfoRequest
3980 //
3981 // @param runtime - runtime options for this request RuntimeOptions
3982 //
3983 // @return DescribeCloudGtmInstanceConfigFullInfoResponse
3984 func DescribeCloudGtmInstanceConfigFullInfoWithOptions(client *Client, request *DescribeCloudGtmInstanceConfigFullInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmInstanceConfigFullInfoResponse, _err error) {
3985 if dara.BoolValue(client.EnableValidate) == true {
3986 _err = request.Validate()
3987 if _err != nil {
3988 return _result, _err
3989 }
3990 }
3991 query := map[string]interface{}{}
3992 if !dara.IsNil(request.AcceptLanguage) {
3993 query["AcceptLanguage"] = request.AcceptLanguage
3994 }
3995
3996 if !dara.IsNil(request.ClientToken) {
3997 query["ClientToken"] = request.ClientToken
3998 }
3999
4000 if !dara.IsNil(request.ConfigId) {
4001 query["ConfigId"] = request.ConfigId
4002 }
4003
4004 if !dara.IsNil(request.InstanceId) {
4005 query["InstanceId"] = request.InstanceId
4006 }
4007
4008 req := &openapiutil.OpenApiRequest{
4009 Query: openapiutil.Query(query),
4010 }
4011 params := &openapiutil.Params{
4012 Action: dara.String("DescribeCloudGtmInstanceConfigFullInfo"),
4013 Version: dara.String("2015-01-09"),
4014 Protocol: dara.String("HTTPS"),
4015 Pathname: dara.String("/"),
4016 Method: dara.String("POST"),
4017 AuthType: dara.String("AK"),
4018 Style: dara.String("RPC"),
4019 ReqBodyType: dara.String("formData"),
4020 BodyType: dara.String("json"),
4021 }
4022 _result = &DescribeCloudGtmInstanceConfigFullInfoResponse{}
4023 _body, _err := client.CallApi(params, req, runtime)
4024 if _err != nil {
4025 return _result, _err
4026 }
4027 _err = dara.Convert(_body, &_result)
4028 return _result, _err
4029 }
4030
4031 // Summary:
4032 //
4033 // Queries the complete configuration information about a Global Traffic Manager (GTM) instance.
4034 //
4035 // @param request - DescribeCloudGtmInstanceConfigFullInfoRequest
4036 //
4037 // @return DescribeCloudGtmInstanceConfigFullInfoResponse
4038 func DescribeCloudGtmInstanceConfigFullInfo(client *Client, request *DescribeCloudGtmInstanceConfigFullInfoRequest) (_result *DescribeCloudGtmInstanceConfigFullInfoResponse, _err error) {
4039 runtime := &dara.RuntimeOptions{}
4040 _result = &DescribeCloudGtmInstanceConfigFullInfoResponse{}
4041 _body, _err := DescribeCloudGtmInstanceConfigFullInfoWithOptions(client,request, runtime)
4042 if _err != nil {
4043 return _result, _err
4044 }
4045 _result = _body
4046 return _result, _err
4047 }
4048
4049 // Summary:
4050 //
4051 // Queries the configurations of a health check template.
4052 //
4053 // @param request - DescribeCloudGtmMonitorTemplateRequest
4054 //
4055 // @param runtime - runtime options for this request RuntimeOptions
4056 //
4057 // @return DescribeCloudGtmMonitorTemplateResponse
4058 func DescribeCloudGtmMonitorTemplateWithOptions(client *Client, request *DescribeCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmMonitorTemplateResponse, _err error) {
4059 if dara.BoolValue(client.EnableValidate) == true {
4060 _err = request.Validate()
4061 if _err != nil {
4062 return _result, _err
4063 }
4064 }
4065 query := map[string]interface{}{}
4066 if !dara.IsNil(request.AcceptLanguage) {
4067 query["AcceptLanguage"] = request.AcceptLanguage
4068 }
4069
4070 if !dara.IsNil(request.TemplateId) {
4071 query["TemplateId"] = request.TemplateId
4072 }
4073
4074 req := &openapiutil.OpenApiRequest{
4075 Query: openapiutil.Query(query),
4076 }
4077 params := &openapiutil.Params{
4078 Action: dara.String("DescribeCloudGtmMonitorTemplate"),
4079 Version: dara.String("2015-01-09"),
4080 Protocol: dara.String("HTTPS"),
4081 Pathname: dara.String("/"),
4082 Method: dara.String("POST"),
4083 AuthType: dara.String("AK"),
4084 Style: dara.String("RPC"),
4085 ReqBodyType: dara.String("formData"),
4086 BodyType: dara.String("json"),
4087 }
4088 _result = &DescribeCloudGtmMonitorTemplateResponse{}
4089 _body, _err := client.CallApi(params, req, runtime)
4090 if _err != nil {
4091 return _result, _err
4092 }
4093 _err = dara.Convert(_body, &_result)
4094 return _result, _err
4095 }
4096
4097 // Summary:
4098 //
4099 // Queries the configurations of a health check template.
4100 //
4101 // @param request - DescribeCloudGtmMonitorTemplateRequest
4102 //
4103 // @return DescribeCloudGtmMonitorTemplateResponse
4104 func DescribeCloudGtmMonitorTemplate(client *Client, request *DescribeCloudGtmMonitorTemplateRequest) (_result *DescribeCloudGtmMonitorTemplateResponse, _err error) {
4105 runtime := &dara.RuntimeOptions{}
4106 _result = &DescribeCloudGtmMonitorTemplateResponse{}
4107 _body, _err := DescribeCloudGtmMonitorTemplateWithOptions(client,request, runtime)
4108 if _err != nil {
4109 return _result, _err
4110 }
4111 _result = _body
4112 return _result, _err
4113 }
4114
4115 // @param request - DescribeCloudGtmSummaryRequest
4116 //
4117 // @param runtime - runtime options for this request RuntimeOptions
4118 //
4119 // @return DescribeCloudGtmSummaryResponse
4120 func DescribeCloudGtmSummaryWithOptions(client *Client, request *DescribeCloudGtmSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmSummaryResponse, _err error) {
4121 if dara.BoolValue(client.EnableValidate) == true {
4122 _err = request.Validate()
4123 if _err != nil {
4124 return _result, _err
4125 }
4126 }
4127 query := map[string]interface{}{}
4128 if !dara.IsNil(request.AcceptLanguage) {
4129 query["AcceptLanguage"] = request.AcceptLanguage
4130 }
4131
4132 req := &openapiutil.OpenApiRequest{
4133 Query: openapiutil.Query(query),
4134 }
4135 params := &openapiutil.Params{
4136 Action: dara.String("DescribeCloudGtmSummary"),
4137 Version: dara.String("2015-01-09"),
4138 Protocol: dara.String("HTTPS"),
4139 Pathname: dara.String("/"),
4140 Method: dara.String("POST"),
4141 AuthType: dara.String("AK"),
4142 Style: dara.String("RPC"),
4143 ReqBodyType: dara.String("formData"),
4144 BodyType: dara.String("json"),
4145 }
4146 _result = &DescribeCloudGtmSummaryResponse{}
4147 _body, _err := client.CallApi(params, req, runtime)
4148 if _err != nil {
4149 return _result, _err
4150 }
4151 _err = dara.Convert(_body, &_result)
4152 return _result, _err
4153 }
4154
4155 // @param request - DescribeCloudGtmSummaryRequest
4156 //
4157 // @return DescribeCloudGtmSummaryResponse
4158 func DescribeCloudGtmSummary(client *Client, request *DescribeCloudGtmSummaryRequest) (_result *DescribeCloudGtmSummaryResponse, _err error) {
4159 runtime := &dara.RuntimeOptions{}
4160 _result = &DescribeCloudGtmSummaryResponse{}
4161 _body, _err := DescribeCloudGtmSummaryWithOptions(client,request, runtime)
4162 if _err != nil {
4163 return _result, _err
4164 }
4165 _result = _body
4166 return _result, _err
4167 }
4168
4169 // @param request - DescribeCloudGtmSystemLinesRequest
4170 //
4171 // @param runtime - runtime options for this request RuntimeOptions
4172 //
4173 // @return DescribeCloudGtmSystemLinesResponse
4174 func DescribeCloudGtmSystemLinesWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmSystemLinesResponse, _err error) {
4175 req := &openapiutil.OpenApiRequest{}
4176 params := &openapiutil.Params{
4177 Action: dara.String("DescribeCloudGtmSystemLines"),
4178 Version: dara.String("2015-01-09"),
4179 Protocol: dara.String("HTTPS"),
4180 Pathname: dara.String("/"),
4181 Method: dara.String("POST"),
4182 AuthType: dara.String("AK"),
4183 Style: dara.String("RPC"),
4184 ReqBodyType: dara.String("formData"),
4185 BodyType: dara.String("json"),
4186 }
4187 _result = &DescribeCloudGtmSystemLinesResponse{}
4188 _body, _err := client.CallApi(params, req, runtime)
4189 if _err != nil {
4190 return _result, _err
4191 }
4192 _err = dara.Convert(_body, &_result)
4193 return _result, _err
4194 }
4195
4196 // @return DescribeCloudGtmSystemLinesResponse
4197 func DescribeCloudGtmSystemLines(client *Client, ) (_result *DescribeCloudGtmSystemLinesResponse, _err error) {
4198 runtime := &dara.RuntimeOptions{}
4199 _result = &DescribeCloudGtmSystemLinesResponse{}
4200 _body, _err := DescribeCloudGtmSystemLinesWithOptions(client,runtime)
4201 if _err != nil {
4202 return _result, _err
4203 }
4204 _result = _body
4205 return _result, _err
4206 }
4207
4208 // Summary:
4209 //
4210 // Queries the details of a custom line by its unique ID.
4211 //
4212 // @param request - DescribeCustomLineRequest
4213 //
4214 // @param runtime - runtime options for this request RuntimeOptions
4215 //
4216 // @return DescribeCustomLineResponse
4217 func DescribeCustomLineWithOptions(client *Client, request *DescribeCustomLineRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomLineResponse, _err error) {
4218 if dara.BoolValue(client.EnableValidate) == true {
4219 _err = request.Validate()
4220 if _err != nil {
4221 return _result, _err
4222 }
4223 }
4224 query := map[string]interface{}{}
4225 if !dara.IsNil(request.Lang) {
4226 query["Lang"] = request.Lang
4227 }
4228
4229 if !dara.IsNil(request.LineId) {
4230 query["LineId"] = request.LineId
4231 }
4232
4233 req := &openapiutil.OpenApiRequest{
4234 Query: openapiutil.Query(query),
4235 }
4236 params := &openapiutil.Params{
4237 Action: dara.String("DescribeCustomLine"),
4238 Version: dara.String("2015-01-09"),
4239 Protocol: dara.String("HTTPS"),
4240 Pathname: dara.String("/"),
4241 Method: dara.String("POST"),
4242 AuthType: dara.String("AK"),
4243 Style: dara.String("RPC"),
4244 ReqBodyType: dara.String("formData"),
4245 BodyType: dara.String("json"),
4246 }
4247 _result = &DescribeCustomLineResponse{}
4248 _body, _err := client.CallApi(params, req, runtime)
4249 if _err != nil {
4250 return _result, _err
4251 }
4252 _err = dara.Convert(_body, &_result)
4253 return _result, _err
4254 }
4255
4256 // Summary:
4257 //
4258 // Queries the details of a custom line by its unique ID.
4259 //
4260 // @param request - DescribeCustomLineRequest
4261 //
4262 // @return DescribeCustomLineResponse
4263 func DescribeCustomLine(client *Client, request *DescribeCustomLineRequest) (_result *DescribeCustomLineResponse, _err error) {
4264 runtime := &dara.RuntimeOptions{}
4265 _result = &DescribeCustomLineResponse{}
4266 _body, _err := DescribeCustomLineWithOptions(client,request, runtime)
4267 if _err != nil {
4268 return _result, _err
4269 }
4270 _result = _body
4271 return _result, _err
4272 }
4273
4274 // Summary:
4275 //
4276 // Queries custom lines by domain name.
4277 //
4278 // @param request - DescribeCustomLinesRequest
4279 //
4280 // @param runtime - runtime options for this request RuntimeOptions
4281 //
4282 // @return DescribeCustomLinesResponse
4283 func DescribeCustomLinesWithOptions(client *Client, request *DescribeCustomLinesRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomLinesResponse, _err error) {
4284 if dara.BoolValue(client.EnableValidate) == true {
4285 _err = request.Validate()
4286 if _err != nil {
4287 return _result, _err
4288 }
4289 }
4290 query := map[string]interface{}{}
4291 if !dara.IsNil(request.DomainName) {
4292 query["DomainName"] = request.DomainName
4293 }
4294
4295 if !dara.IsNil(request.Lang) {
4296 query["Lang"] = request.Lang
4297 }
4298
4299 if !dara.IsNil(request.PageNumber) {
4300 query["PageNumber"] = request.PageNumber
4301 }
4302
4303 if !dara.IsNil(request.PageSize) {
4304 query["PageSize"] = request.PageSize
4305 }
4306
4307 req := &openapiutil.OpenApiRequest{
4308 Query: openapiutil.Query(query),
4309 }
4310 params := &openapiutil.Params{
4311 Action: dara.String("DescribeCustomLines"),
4312 Version: dara.String("2015-01-09"),
4313 Protocol: dara.String("HTTPS"),
4314 Pathname: dara.String("/"),
4315 Method: dara.String("POST"),
4316 AuthType: dara.String("AK"),
4317 Style: dara.String("RPC"),
4318 ReqBodyType: dara.String("formData"),
4319 BodyType: dara.String("json"),
4320 }
4321 _result = &DescribeCustomLinesResponse{}
4322 _body, _err := client.CallApi(params, req, runtime)
4323 if _err != nil {
4324 return _result, _err
4325 }
4326 _err = dara.Convert(_body, &_result)
4327 return _result, _err
4328 }
4329
4330 // Summary:
4331 //
4332 // Queries custom lines by domain name.
4333 //
4334 // @param request - DescribeCustomLinesRequest
4335 //
4336 // @return DescribeCustomLinesResponse
4337 func DescribeCustomLines(client *Client, request *DescribeCustomLinesRequest) (_result *DescribeCustomLinesResponse, _err error) {
4338 runtime := &dara.RuntimeOptions{}
4339 _result = &DescribeCustomLinesResponse{}
4340 _body, _err := DescribeCustomLinesWithOptions(client,request, runtime)
4341 if _err != nil {
4342 return _result, _err
4343 }
4344 _result = _body
4345 return _result, _err
4346 }
4347
4348 // Summary:
4349 //
4350 // Queries the subdomains for which weighted round-robin is enabled based on the specified parameters.
4351 //
4352 // @param request - DescribeDNSSLBSubDomainsRequest
4353 //
4354 // @param runtime - runtime options for this request RuntimeOptions
4355 //
4356 // @return DescribeDNSSLBSubDomainsResponse
4357 func DescribeDNSSLBSubDomainsWithOptions(client *Client, request *DescribeDNSSLBSubDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDNSSLBSubDomainsResponse, _err error) {
4358 if dara.BoolValue(client.EnableValidate) == true {
4359 _err = request.Validate()
4360 if _err != nil {
4361 return _result, _err
4362 }
4363 }
4364 query := map[string]interface{}{}
4365 if !dara.IsNil(request.DomainName) {
4366 query["DomainName"] = request.DomainName
4367 }
4368
4369 if !dara.IsNil(request.Lang) {
4370 query["Lang"] = request.Lang
4371 }
4372
4373 if !dara.IsNil(request.PageNumber) {
4374 query["PageNumber"] = request.PageNumber
4375 }
4376
4377 if !dara.IsNil(request.PageSize) {
4378 query["PageSize"] = request.PageSize
4379 }
4380
4381 if !dara.IsNil(request.Rr) {
4382 query["Rr"] = request.Rr
4383 }
4384
4385 if !dara.IsNil(request.UserClientIp) {
4386 query["UserClientIp"] = request.UserClientIp
4387 }
4388
4389 req := &openapiutil.OpenApiRequest{
4390 Query: openapiutil.Query(query),
4391 }
4392 params := &openapiutil.Params{
4393 Action: dara.String("DescribeDNSSLBSubDomains"),
4394 Version: dara.String("2015-01-09"),
4395 Protocol: dara.String("HTTPS"),
4396 Pathname: dara.String("/"),
4397 Method: dara.String("POST"),
4398 AuthType: dara.String("AK"),
4399 Style: dara.String("RPC"),
4400 ReqBodyType: dara.String("formData"),
4401 BodyType: dara.String("json"),
4402 }
4403 _result = &DescribeDNSSLBSubDomainsResponse{}
4404 _body, _err := client.CallApi(params, req, runtime)
4405 if _err != nil {
4406 return _result, _err
4407 }
4408 _err = dara.Convert(_body, &_result)
4409 return _result, _err
4410 }
4411
4412 // Summary:
4413 //
4414 // Queries the subdomains for which weighted round-robin is enabled based on the specified parameters.
4415 //
4416 // @param request - DescribeDNSSLBSubDomainsRequest
4417 //
4418 // @return DescribeDNSSLBSubDomainsResponse
4419 func DescribeDNSSLBSubDomains(client *Client, request *DescribeDNSSLBSubDomainsRequest) (_result *DescribeDNSSLBSubDomainsResponse, _err error) {
4420 runtime := &dara.RuntimeOptions{}
4421 _result = &DescribeDNSSLBSubDomainsResponse{}
4422 _body, _err := DescribeDNSSLBSubDomainsWithOptions(client,request, runtime)
4423 if _err != nil {
4424 return _result, _err
4425 }
4426 _result = _body
4427 return _result, _err
4428 }
4429
4430 // Summary:
4431 //
4432 // 查询代理域名
4433 //
4434 // @param request - DescribeDnsCacheDomainsRequest
4435 //
4436 // @param runtime - runtime options for this request RuntimeOptions
4437 //
4438 // @return DescribeDnsCacheDomainsResponse
4439 func DescribeDnsCacheDomainsWithOptions(client *Client, request *DescribeDnsCacheDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsCacheDomainsResponse, _err error) {
4440 if dara.BoolValue(client.EnableValidate) == true {
4441 _err = request.Validate()
4442 if _err != nil {
4443 return _result, _err
4444 }
4445 }
4446 query := map[string]interface{}{}
4447 if !dara.IsNil(request.Keyword) {
4448 query["Keyword"] = request.Keyword
4449 }
4450
4451 if !dara.IsNil(request.Lang) {
4452 query["Lang"] = request.Lang
4453 }
4454
4455 if !dara.IsNil(request.PageNumber) {
4456 query["PageNumber"] = request.PageNumber
4457 }
4458
4459 if !dara.IsNil(request.PageSize) {
4460 query["PageSize"] = request.PageSize
4461 }
4462
4463 req := &openapiutil.OpenApiRequest{
4464 Query: openapiutil.Query(query),
4465 }
4466 params := &openapiutil.Params{
4467 Action: dara.String("DescribeDnsCacheDomains"),
4468 Version: dara.String("2015-01-09"),
4469 Protocol: dara.String("HTTPS"),
4470 Pathname: dara.String("/"),
4471 Method: dara.String("POST"),
4472 AuthType: dara.String("AK"),
4473 Style: dara.String("RPC"),
4474 ReqBodyType: dara.String("formData"),
4475 BodyType: dara.String("json"),
4476 }
4477 _result = &DescribeDnsCacheDomainsResponse{}
4478 _body, _err := client.CallApi(params, req, runtime)
4479 if _err != nil {
4480 return _result, _err
4481 }
4482 _err = dara.Convert(_body, &_result)
4483 return _result, _err
4484 }
4485
4486 // Summary:
4487 //
4488 // 查询代理域名
4489 //
4490 // @param request - DescribeDnsCacheDomainsRequest
4491 //
4492 // @return DescribeDnsCacheDomainsResponse
4493 func DescribeDnsCacheDomains(client *Client, request *DescribeDnsCacheDomainsRequest) (_result *DescribeDnsCacheDomainsResponse, _err error) {
4494 runtime := &dara.RuntimeOptions{}
4495 _result = &DescribeDnsCacheDomainsResponse{}
4496 _body, _err := DescribeDnsCacheDomainsWithOptions(client,request, runtime)
4497 if _err != nil {
4498 return _result, _err
4499 }
4500 _result = _body
4501 return _result, _err
4502 }
4503
4504 // Summary:
4505 //
4506 // Queries access policies of a Global Traffic Manager (GTM) instance.
4507 //
4508 // @param request - DescribeDnsGtmAccessStrategiesRequest
4509 //
4510 // @param runtime - runtime options for this request RuntimeOptions
4511 //
4512 // @return DescribeDnsGtmAccessStrategiesResponse
4513 func DescribeDnsGtmAccessStrategiesWithOptions(client *Client, request *DescribeDnsGtmAccessStrategiesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategiesResponse, _err error) {
4514 if dara.BoolValue(client.EnableValidate) == true {
4515 _err = request.Validate()
4516 if _err != nil {
4517 return _result, _err
4518 }
4519 }
4520 query := map[string]interface{}{}
4521 if !dara.IsNil(request.InstanceId) {
4522 query["InstanceId"] = request.InstanceId
4523 }
4524
4525 if !dara.IsNil(request.Lang) {
4526 query["Lang"] = request.Lang
4527 }
4528
4529 if !dara.IsNil(request.PageNumber) {
4530 query["PageNumber"] = request.PageNumber
4531 }
4532
4533 if !dara.IsNil(request.PageSize) {
4534 query["PageSize"] = request.PageSize
4535 }
4536
4537 if !dara.IsNil(request.StrategyMode) {
4538 query["StrategyMode"] = request.StrategyMode
4539 }
4540
4541 req := &openapiutil.OpenApiRequest{
4542 Query: openapiutil.Query(query),
4543 }
4544 params := &openapiutil.Params{
4545 Action: dara.String("DescribeDnsGtmAccessStrategies"),
4546 Version: dara.String("2015-01-09"),
4547 Protocol: dara.String("HTTPS"),
4548 Pathname: dara.String("/"),
4549 Method: dara.String("POST"),
4550 AuthType: dara.String("AK"),
4551 Style: dara.String("RPC"),
4552 ReqBodyType: dara.String("formData"),
4553 BodyType: dara.String("json"),
4554 }
4555 _result = &DescribeDnsGtmAccessStrategiesResponse{}
4556 _body, _err := client.CallApi(params, req, runtime)
4557 if _err != nil {
4558 return _result, _err
4559 }
4560 _err = dara.Convert(_body, &_result)
4561 return _result, _err
4562 }
4563
4564 // Summary:
4565 //
4566 // Queries access policies of a Global Traffic Manager (GTM) instance.
4567 //
4568 // @param request - DescribeDnsGtmAccessStrategiesRequest
4569 //
4570 // @return DescribeDnsGtmAccessStrategiesResponse
4571 func DescribeDnsGtmAccessStrategies(client *Client, request *DescribeDnsGtmAccessStrategiesRequest) (_result *DescribeDnsGtmAccessStrategiesResponse, _err error) {
4572 runtime := &dara.RuntimeOptions{}
4573 _result = &DescribeDnsGtmAccessStrategiesResponse{}
4574 _body, _err := DescribeDnsGtmAccessStrategiesWithOptions(client,request, runtime)
4575 if _err != nil {
4576 return _result, _err
4577 }
4578 _result = _body
4579 return _result, _err
4580 }
4581
4582 // Summary:
4583 //
4584 // Queries detailed information about an access policy of a Global Traffic Manager (GTM) instance.
4585 //
4586 // @param request - DescribeDnsGtmAccessStrategyRequest
4587 //
4588 // @param runtime - runtime options for this request RuntimeOptions
4589 //
4590 // @return DescribeDnsGtmAccessStrategyResponse
4591 func DescribeDnsGtmAccessStrategyWithOptions(client *Client, request *DescribeDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategyResponse, _err error) {
4592 if dara.BoolValue(client.EnableValidate) == true {
4593 _err = request.Validate()
4594 if _err != nil {
4595 return _result, _err
4596 }
4597 }
4598 query := map[string]interface{}{}
4599 if !dara.IsNil(request.Lang) {
4600 query["Lang"] = request.Lang
4601 }
4602
4603 if !dara.IsNil(request.StrategyId) {
4604 query["StrategyId"] = request.StrategyId
4605 }
4606
4607 req := &openapiutil.OpenApiRequest{
4608 Query: openapiutil.Query(query),
4609 }
4610 params := &openapiutil.Params{
4611 Action: dara.String("DescribeDnsGtmAccessStrategy"),
4612 Version: dara.String("2015-01-09"),
4613 Protocol: dara.String("HTTPS"),
4614 Pathname: dara.String("/"),
4615 Method: dara.String("POST"),
4616 AuthType: dara.String("AK"),
4617 Style: dara.String("RPC"),
4618 ReqBodyType: dara.String("formData"),
4619 BodyType: dara.String("json"),
4620 }
4621 _result = &DescribeDnsGtmAccessStrategyResponse{}
4622 _body, _err := client.CallApi(params, req, runtime)
4623 if _err != nil {
4624 return _result, _err
4625 }
4626 _err = dara.Convert(_body, &_result)
4627 return _result, _err
4628 }
4629
4630 // Summary:
4631 //
4632 // Queries detailed information about an access policy of a Global Traffic Manager (GTM) instance.
4633 //
4634 // @param request - DescribeDnsGtmAccessStrategyRequest
4635 //
4636 // @return DescribeDnsGtmAccessStrategyResponse
4637 func DescribeDnsGtmAccessStrategy(client *Client, request *DescribeDnsGtmAccessStrategyRequest) (_result *DescribeDnsGtmAccessStrategyResponse, _err error) {
4638 runtime := &dara.RuntimeOptions{}
4639 _result = &DescribeDnsGtmAccessStrategyResponse{}
4640 _body, _err := DescribeDnsGtmAccessStrategyWithOptions(client,request, runtime)
4641 if _err != nil {
4642 return _result, _err
4643 }
4644 _result = _body
4645 return _result, _err
4646 }
4647
4648 // Summary:
4649 //
4650 // Queries the available configurations of an access policy of a Global Traffic Manager (GTM) instance.
4651 //
4652 // @param request - DescribeDnsGtmAccessStrategyAvailableConfigRequest
4653 //
4654 // @param runtime - runtime options for this request RuntimeOptions
4655 //
4656 // @return DescribeDnsGtmAccessStrategyAvailableConfigResponse
4657 func DescribeDnsGtmAccessStrategyAvailableConfigWithOptions(client *Client, request *DescribeDnsGtmAccessStrategyAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategyAvailableConfigResponse, _err error) {
4658 if dara.BoolValue(client.EnableValidate) == true {
4659 _err = request.Validate()
4660 if _err != nil {
4661 return _result, _err
4662 }
4663 }
4664 query := map[string]interface{}{}
4665 if !dara.IsNil(request.InstanceId) {
4666 query["InstanceId"] = request.InstanceId
4667 }
4668
4669 if !dara.IsNil(request.Lang) {
4670 query["Lang"] = request.Lang
4671 }
4672
4673 if !dara.IsNil(request.StrategyMode) {
4674 query["StrategyMode"] = request.StrategyMode
4675 }
4676
4677 req := &openapiutil.OpenApiRequest{
4678 Query: openapiutil.Query(query),
4679 }
4680 params := &openapiutil.Params{
4681 Action: dara.String("DescribeDnsGtmAccessStrategyAvailableConfig"),
4682 Version: dara.String("2015-01-09"),
4683 Protocol: dara.String("HTTPS"),
4684 Pathname: dara.String("/"),
4685 Method: dara.String("POST"),
4686 AuthType: dara.String("AK"),
4687 Style: dara.String("RPC"),
4688 ReqBodyType: dara.String("formData"),
4689 BodyType: dara.String("json"),
4690 }
4691 _result = &DescribeDnsGtmAccessStrategyAvailableConfigResponse{}
4692 _body, _err := client.CallApi(params, req, runtime)
4693 if _err != nil {
4694 return _result, _err
4695 }
4696 _err = dara.Convert(_body, &_result)
4697 return _result, _err
4698 }
4699
4700 // Summary:
4701 //
4702 // Queries the available configurations of an access policy of a Global Traffic Manager (GTM) instance.
4703 //
4704 // @param request - DescribeDnsGtmAccessStrategyAvailableConfigRequest
4705 //
4706 // @return DescribeDnsGtmAccessStrategyAvailableConfigResponse
4707 func DescribeDnsGtmAccessStrategyAvailableConfig(client *Client, request *DescribeDnsGtmAccessStrategyAvailableConfigRequest) (_result *DescribeDnsGtmAccessStrategyAvailableConfigResponse, _err error) {
4708 runtime := &dara.RuntimeOptions{}
4709 _result = &DescribeDnsGtmAccessStrategyAvailableConfigResponse{}
4710 _body, _err := DescribeDnsGtmAccessStrategyAvailableConfigWithOptions(client,request, runtime)
4711 if _err != nil {
4712 return _result, _err
4713 }
4714 _result = _body
4715 return _result, _err
4716 }
4717
4718 // Summary:
4719 //
4720 // Queries the source regions of addresses.
4721 //
4722 // @param request - DescribeDnsGtmAddrAttributeInfoRequest
4723 //
4724 // @param runtime - runtime options for this request RuntimeOptions
4725 //
4726 // @return DescribeDnsGtmAddrAttributeInfoResponse
4727 func DescribeDnsGtmAddrAttributeInfoWithOptions(client *Client, request *DescribeDnsGtmAddrAttributeInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAddrAttributeInfoResponse, _err error) {
4728 if dara.BoolValue(client.EnableValidate) == true {
4729 _err = request.Validate()
4730 if _err != nil {
4731 return _result, _err
4732 }
4733 }
4734 query := map[string]interface{}{}
4735 if !dara.IsNil(request.Addrs) {
4736 query["Addrs"] = request.Addrs
4737 }
4738
4739 if !dara.IsNil(request.Lang) {
4740 query["Lang"] = request.Lang
4741 }
4742
4743 if !dara.IsNil(request.Type) {
4744 query["Type"] = request.Type
4745 }
4746
4747 req := &openapiutil.OpenApiRequest{
4748 Query: openapiutil.Query(query),
4749 }
4750 params := &openapiutil.Params{
4751 Action: dara.String("DescribeDnsGtmAddrAttributeInfo"),
4752 Version: dara.String("2015-01-09"),
4753 Protocol: dara.String("HTTPS"),
4754 Pathname: dara.String("/"),
4755 Method: dara.String("POST"),
4756 AuthType: dara.String("AK"),
4757 Style: dara.String("RPC"),
4758 ReqBodyType: dara.String("formData"),
4759 BodyType: dara.String("json"),
4760 }
4761 _result = &DescribeDnsGtmAddrAttributeInfoResponse{}
4762 _body, _err := client.CallApi(params, req, runtime)
4763 if _err != nil {
4764 return _result, _err
4765 }
4766 _err = dara.Convert(_body, &_result)
4767 return _result, _err
4768 }
4769
4770 // Summary:
4771 //
4772 // Queries the source regions of addresses.
4773 //
4774 // @param request - DescribeDnsGtmAddrAttributeInfoRequest
4775 //
4776 // @return DescribeDnsGtmAddrAttributeInfoResponse
4777 func DescribeDnsGtmAddrAttributeInfo(client *Client, request *DescribeDnsGtmAddrAttributeInfoRequest) (_result *DescribeDnsGtmAddrAttributeInfoResponse, _err error) {
4778 runtime := &dara.RuntimeOptions{}
4779 _result = &DescribeDnsGtmAddrAttributeInfoResponse{}
4780 _body, _err := DescribeDnsGtmAddrAttributeInfoWithOptions(client,request, runtime)
4781 if _err != nil {
4782 return _result, _err
4783 }
4784 _result = _body
4785 return _result, _err
4786 }
4787
4788 // Summary:
4789 //
4790 // Queries the available configurations of an address pool of a Global Traffic Manager (GTM) instance.
4791 //
4792 // @param request - DescribeDnsGtmAddressPoolAvailableConfigRequest
4793 //
4794 // @param runtime - runtime options for this request RuntimeOptions
4795 //
4796 // @return DescribeDnsGtmAddressPoolAvailableConfigResponse
4797 func DescribeDnsGtmAddressPoolAvailableConfigWithOptions(client *Client, request *DescribeDnsGtmAddressPoolAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAddressPoolAvailableConfigResponse, _err error) {
4798 if dara.BoolValue(client.EnableValidate) == true {
4799 _err = request.Validate()
4800 if _err != nil {
4801 return _result, _err
4802 }
4803 }
4804 query := map[string]interface{}{}
4805 if !dara.IsNil(request.InstanceId) {
4806 query["InstanceId"] = request.InstanceId
4807 }
4808
4809 if !dara.IsNil(request.Lang) {
4810 query["Lang"] = request.Lang
4811 }
4812
4813 req := &openapiutil.OpenApiRequest{
4814 Query: openapiutil.Query(query),
4815 }
4816 params := &openapiutil.Params{
4817 Action: dara.String("DescribeDnsGtmAddressPoolAvailableConfig"),
4818 Version: dara.String("2015-01-09"),
4819 Protocol: dara.String("HTTPS"),
4820 Pathname: dara.String("/"),
4821 Method: dara.String("POST"),
4822 AuthType: dara.String("AK"),
4823 Style: dara.String("RPC"),
4824 ReqBodyType: dara.String("formData"),
4825 BodyType: dara.String("json"),
4826 }
4827 _result = &DescribeDnsGtmAddressPoolAvailableConfigResponse{}
4828 _body, _err := client.CallApi(params, req, runtime)
4829 if _err != nil {
4830 return _result, _err
4831 }
4832 _err = dara.Convert(_body, &_result)
4833 return _result, _err
4834 }
4835
4836 // Summary:
4837 //
4838 // Queries the available configurations of an address pool of a Global Traffic Manager (GTM) instance.
4839 //
4840 // @param request - DescribeDnsGtmAddressPoolAvailableConfigRequest
4841 //
4842 // @return DescribeDnsGtmAddressPoolAvailableConfigResponse
4843 func DescribeDnsGtmAddressPoolAvailableConfig(client *Client, request *DescribeDnsGtmAddressPoolAvailableConfigRequest) (_result *DescribeDnsGtmAddressPoolAvailableConfigResponse, _err error) {
4844 runtime := &dara.RuntimeOptions{}
4845 _result = &DescribeDnsGtmAddressPoolAvailableConfigResponse{}
4846 _body, _err := DescribeDnsGtmAddressPoolAvailableConfigWithOptions(client,request, runtime)
4847 if _err != nil {
4848 return _result, _err
4849 }
4850 _result = _body
4851 return _result, _err
4852 }
4853
4854 // @param request - DescribeDnsGtmAvailableAlertGroupRequest
4855 //
4856 // @param runtime - runtime options for this request RuntimeOptions
4857 //
4858 // @return DescribeDnsGtmAvailableAlertGroupResponse
4859 func DescribeDnsGtmAvailableAlertGroupWithOptions(client *Client, request *DescribeDnsGtmAvailableAlertGroupRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAvailableAlertGroupResponse, _err error) {
4860 if dara.BoolValue(client.EnableValidate) == true {
4861 _err = request.Validate()
4862 if _err != nil {
4863 return _result, _err
4864 }
4865 }
4866 query := map[string]interface{}{}
4867 if !dara.IsNil(request.Lang) {
4868 query["Lang"] = request.Lang
4869 }
4870
4871 req := &openapiutil.OpenApiRequest{
4872 Query: openapiutil.Query(query),
4873 }
4874 params := &openapiutil.Params{
4875 Action: dara.String("DescribeDnsGtmAvailableAlertGroup"),
4876 Version: dara.String("2015-01-09"),
4877 Protocol: dara.String("HTTPS"),
4878 Pathname: dara.String("/"),
4879 Method: dara.String("POST"),
4880 AuthType: dara.String("AK"),
4881 Style: dara.String("RPC"),
4882 ReqBodyType: dara.String("formData"),
4883 BodyType: dara.String("json"),
4884 }
4885 _result = &DescribeDnsGtmAvailableAlertGroupResponse{}
4886 _body, _err := client.CallApi(params, req, runtime)
4887 if _err != nil {
4888 return _result, _err
4889 }
4890 _err = dara.Convert(_body, &_result)
4891 return _result, _err
4892 }
4893
4894 // @param request - DescribeDnsGtmAvailableAlertGroupRequest
4895 //
4896 // @return DescribeDnsGtmAvailableAlertGroupResponse
4897 func DescribeDnsGtmAvailableAlertGroup(client *Client, request *DescribeDnsGtmAvailableAlertGroupRequest) (_result *DescribeDnsGtmAvailableAlertGroupResponse, _err error) {
4898 runtime := &dara.RuntimeOptions{}
4899 _result = &DescribeDnsGtmAvailableAlertGroupResponse{}
4900 _body, _err := DescribeDnsGtmAvailableAlertGroupWithOptions(client,request, runtime)
4901 if _err != nil {
4902 return _result, _err
4903 }
4904 _result = _body
4905 return _result, _err
4906 }
4907
4908 // Summary:
4909 //
4910 // Queries detailed information about a Global Traffic Manager (GTM) instance.
4911 //
4912 // @param request - DescribeDnsGtmInstanceRequest
4913 //
4914 // @param runtime - runtime options for this request RuntimeOptions
4915 //
4916 // @return DescribeDnsGtmInstanceResponse
4917 func DescribeDnsGtmInstanceWithOptions(client *Client, request *DescribeDnsGtmInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceResponse, _err error) {
4918 if dara.BoolValue(client.EnableValidate) == true {
4919 _err = request.Validate()
4920 if _err != nil {
4921 return _result, _err
4922 }
4923 }
4924 query := map[string]interface{}{}
4925 if !dara.IsNil(request.InstanceId) {
4926 query["InstanceId"] = request.InstanceId
4927 }
4928
4929 if !dara.IsNil(request.Lang) {
4930 query["Lang"] = request.Lang
4931 }
4932
4933 req := &openapiutil.OpenApiRequest{
4934 Query: openapiutil.Query(query),
4935 }
4936 params := &openapiutil.Params{
4937 Action: dara.String("DescribeDnsGtmInstance"),
4938 Version: dara.String("2015-01-09"),
4939 Protocol: dara.String("HTTPS"),
4940 Pathname: dara.String("/"),
4941 Method: dara.String("POST"),
4942 AuthType: dara.String("AK"),
4943 Style: dara.String("RPC"),
4944 ReqBodyType: dara.String("formData"),
4945 BodyType: dara.String("json"),
4946 }
4947 _result = &DescribeDnsGtmInstanceResponse{}
4948 _body, _err := client.CallApi(params, req, runtime)
4949 if _err != nil {
4950 return _result, _err
4951 }
4952 _err = dara.Convert(_body, &_result)
4953 return _result, _err
4954 }
4955
4956 // Summary:
4957 //
4958 // Queries detailed information about a Global Traffic Manager (GTM) instance.
4959 //
4960 // @param request - DescribeDnsGtmInstanceRequest
4961 //
4962 // @return DescribeDnsGtmInstanceResponse
4963 func DescribeDnsGtmInstance(client *Client, request *DescribeDnsGtmInstanceRequest) (_result *DescribeDnsGtmInstanceResponse, _err error) {
4964 runtime := &dara.RuntimeOptions{}
4965 _result = &DescribeDnsGtmInstanceResponse{}
4966 _body, _err := DescribeDnsGtmInstanceWithOptions(client,request, runtime)
4967 if _err != nil {
4968 return _result, _err
4969 }
4970 _result = _body
4971 return _result, _err
4972 }
4973
4974 // Summary:
4975 //
4976 // Queries detailed information about an address pool of a Global Traffic Manager (GTM) instance.
4977 //
4978 // @param request - DescribeDnsGtmInstanceAddressPoolRequest
4979 //
4980 // @param runtime - runtime options for this request RuntimeOptions
4981 //
4982 // @return DescribeDnsGtmInstanceAddressPoolResponse
4983 func DescribeDnsGtmInstanceAddressPoolWithOptions(client *Client, request *DescribeDnsGtmInstanceAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceAddressPoolResponse, _err error) {
4984 if dara.BoolValue(client.EnableValidate) == true {
4985 _err = request.Validate()
4986 if _err != nil {
4987 return _result, _err
4988 }
4989 }
4990 query := map[string]interface{}{}
4991 if !dara.IsNil(request.AddrPoolId) {
4992 query["AddrPoolId"] = request.AddrPoolId
4993 }
4994
4995 if !dara.IsNil(request.Lang) {
4996 query["Lang"] = request.Lang
4997 }
4998
4999 req := &openapiutil.OpenApiRequest{
5000 Query: openapiutil.Query(query),
5001 }
5002 params := &openapiutil.Params{
5003 Action: dara.String("DescribeDnsGtmInstanceAddressPool"),
5004 Version: dara.String("2015-01-09"),
5005 Protocol: dara.String("HTTPS"),
5006 Pathname: dara.String("/"),
5007 Method: dara.String("POST"),
5008 AuthType: dara.String("AK"),
5009 Style: dara.String("RPC"),
5010 ReqBodyType: dara.String("formData"),
5011 BodyType: dara.String("json"),
5012 }
5013 _result = &DescribeDnsGtmInstanceAddressPoolResponse{}
5014 _body, _err := client.CallApi(params, req, runtime)
5015 if _err != nil {
5016 return _result, _err
5017 }
5018 _err = dara.Convert(_body, &_result)
5019 return _result, _err
5020 }
5021
5022 // Summary:
5023 //
5024 // Queries detailed information about an address pool of a Global Traffic Manager (GTM) instance.
5025 //
5026 // @param request - DescribeDnsGtmInstanceAddressPoolRequest
5027 //
5028 // @return DescribeDnsGtmInstanceAddressPoolResponse
5029 func DescribeDnsGtmInstanceAddressPool(client *Client, request *DescribeDnsGtmInstanceAddressPoolRequest) (_result *DescribeDnsGtmInstanceAddressPoolResponse, _err error) {
5030 runtime := &dara.RuntimeOptions{}
5031 _result = &DescribeDnsGtmInstanceAddressPoolResponse{}
5032 _body, _err := DescribeDnsGtmInstanceAddressPoolWithOptions(client,request, runtime)
5033 if _err != nil {
5034 return _result, _err
5035 }
5036 _result = _body
5037 return _result, _err
5038 }
5039
5040 // Summary:
5041 //
5042 // Queries the address pools of a Global Traffic Manager (GTM) instance.
5043 //
5044 // @param request - DescribeDnsGtmInstanceAddressPoolsRequest
5045 //
5046 // @param runtime - runtime options for this request RuntimeOptions
5047 //
5048 // @return DescribeDnsGtmInstanceAddressPoolsResponse
5049 func DescribeDnsGtmInstanceAddressPoolsWithOptions(client *Client, request *DescribeDnsGtmInstanceAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceAddressPoolsResponse, _err error) {
5050 if dara.BoolValue(client.EnableValidate) == true {
5051 _err = request.Validate()
5052 if _err != nil {
5053 return _result, _err
5054 }
5055 }
5056 query := map[string]interface{}{}
5057 if !dara.IsNil(request.InstanceId) {
5058 query["InstanceId"] = request.InstanceId
5059 }
5060
5061 if !dara.IsNil(request.Lang) {
5062 query["Lang"] = request.Lang
5063 }
5064
5065 if !dara.IsNil(request.PageNumber) {
5066 query["PageNumber"] = request.PageNumber
5067 }
5068
5069 if !dara.IsNil(request.PageSize) {
5070 query["PageSize"] = request.PageSize
5071 }
5072
5073 req := &openapiutil.OpenApiRequest{
5074 Query: openapiutil.Query(query),
5075 }
5076 params := &openapiutil.Params{
5077 Action: dara.String("DescribeDnsGtmInstanceAddressPools"),
5078 Version: dara.String("2015-01-09"),
5079 Protocol: dara.String("HTTPS"),
5080 Pathname: dara.String("/"),
5081 Method: dara.String("POST"),
5082 AuthType: dara.String("AK"),
5083 Style: dara.String("RPC"),
5084 ReqBodyType: dara.String("formData"),
5085 BodyType: dara.String("json"),
5086 }
5087 _result = &DescribeDnsGtmInstanceAddressPoolsResponse{}
5088 _body, _err := client.CallApi(params, req, runtime)
5089 if _err != nil {
5090 return _result, _err
5091 }
5092 _err = dara.Convert(_body, &_result)
5093 return _result, _err
5094 }
5095
5096 // Summary:
5097 //
5098 // Queries the address pools of a Global Traffic Manager (GTM) instance.
5099 //
5100 // @param request - DescribeDnsGtmInstanceAddressPoolsRequest
5101 //
5102 // @return DescribeDnsGtmInstanceAddressPoolsResponse
5103 func DescribeDnsGtmInstanceAddressPools(client *Client, request *DescribeDnsGtmInstanceAddressPoolsRequest) (_result *DescribeDnsGtmInstanceAddressPoolsResponse, _err error) {
5104 runtime := &dara.RuntimeOptions{}
5105 _result = &DescribeDnsGtmInstanceAddressPoolsResponse{}
5106 _body, _err := DescribeDnsGtmInstanceAddressPoolsWithOptions(client,request, runtime)
5107 if _err != nil {
5108 return _result, _err
5109 }
5110 _result = _body
5111 return _result, _err
5112 }
5113
5114 // Summary:
5115 //
5116 // Queries the status of a Global Traffic Manager (GTM) instance.
5117 //
5118 // @param request - DescribeDnsGtmInstanceStatusRequest
5119 //
5120 // @param runtime - runtime options for this request RuntimeOptions
5121 //
5122 // @return DescribeDnsGtmInstanceStatusResponse
5123 func DescribeDnsGtmInstanceStatusWithOptions(client *Client, request *DescribeDnsGtmInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceStatusResponse, _err error) {
5124 if dara.BoolValue(client.EnableValidate) == true {
5125 _err = request.Validate()
5126 if _err != nil {
5127 return _result, _err
5128 }
5129 }
5130 query := map[string]interface{}{}
5131 if !dara.IsNil(request.InstanceId) {
5132 query["InstanceId"] = request.InstanceId
5133 }
5134
5135 if !dara.IsNil(request.Lang) {
5136 query["Lang"] = request.Lang
5137 }
5138
5139 req := &openapiutil.OpenApiRequest{
5140 Query: openapiutil.Query(query),
5141 }
5142 params := &openapiutil.Params{
5143 Action: dara.String("DescribeDnsGtmInstanceStatus"),
5144 Version: dara.String("2015-01-09"),
5145 Protocol: dara.String("HTTPS"),
5146 Pathname: dara.String("/"),
5147 Method: dara.String("POST"),
5148 AuthType: dara.String("AK"),
5149 Style: dara.String("RPC"),
5150 ReqBodyType: dara.String("formData"),
5151 BodyType: dara.String("json"),
5152 }
5153 _result = &DescribeDnsGtmInstanceStatusResponse{}
5154 _body, _err := client.CallApi(params, req, runtime)
5155 if _err != nil {
5156 return _result, _err
5157 }
5158 _err = dara.Convert(_body, &_result)
5159 return _result, _err
5160 }
5161
5162 // Summary:
5163 //
5164 // Queries the status of a Global Traffic Manager (GTM) instance.
5165 //
5166 // @param request - DescribeDnsGtmInstanceStatusRequest
5167 //
5168 // @return DescribeDnsGtmInstanceStatusResponse
5169 func DescribeDnsGtmInstanceStatus(client *Client, request *DescribeDnsGtmInstanceStatusRequest) (_result *DescribeDnsGtmInstanceStatusResponse, _err error) {
5170 runtime := &dara.RuntimeOptions{}
5171 _result = &DescribeDnsGtmInstanceStatusResponse{}
5172 _body, _err := DescribeDnsGtmInstanceStatusWithOptions(client,request, runtime)
5173 if _err != nil {
5174 return _result, _err
5175 }
5176 _result = _body
5177 return _result, _err
5178 }
5179
5180 // Summary:
5181 //
5182 // Queries the CNAME domain name assigned by the system for a Global Traffic Manager (GTM) instance.
5183 //
5184 // @param request - DescribeDnsGtmInstanceSystemCnameRequest
5185 //
5186 // @param runtime - runtime options for this request RuntimeOptions
5187 //
5188 // @return DescribeDnsGtmInstanceSystemCnameResponse
5189 func DescribeDnsGtmInstanceSystemCnameWithOptions(client *Client, request *DescribeDnsGtmInstanceSystemCnameRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceSystemCnameResponse, _err error) {
5190 if dara.BoolValue(client.EnableValidate) == true {
5191 _err = request.Validate()
5192 if _err != nil {
5193 return _result, _err
5194 }
5195 }
5196 query := map[string]interface{}{}
5197 if !dara.IsNil(request.InstanceId) {
5198 query["InstanceId"] = request.InstanceId
5199 }
5200
5201 if !dara.IsNil(request.Lang) {
5202 query["Lang"] = request.Lang
5203 }
5204
5205 req := &openapiutil.OpenApiRequest{
5206 Query: openapiutil.Query(query),
5207 }
5208 params := &openapiutil.Params{
5209 Action: dara.String("DescribeDnsGtmInstanceSystemCname"),
5210 Version: dara.String("2015-01-09"),
5211 Protocol: dara.String("HTTPS"),
5212 Pathname: dara.String("/"),
5213 Method: dara.String("POST"),
5214 AuthType: dara.String("AK"),
5215 Style: dara.String("RPC"),
5216 ReqBodyType: dara.String("formData"),
5217 BodyType: dara.String("json"),
5218 }
5219 _result = &DescribeDnsGtmInstanceSystemCnameResponse{}
5220 _body, _err := client.CallApi(params, req, runtime)
5221 if _err != nil {
5222 return _result, _err
5223 }
5224 _err = dara.Convert(_body, &_result)
5225 return _result, _err
5226 }
5227
5228 // Summary:
5229 //
5230 // Queries the CNAME domain name assigned by the system for a Global Traffic Manager (GTM) instance.
5231 //
5232 // @param request - DescribeDnsGtmInstanceSystemCnameRequest
5233 //
5234 // @return DescribeDnsGtmInstanceSystemCnameResponse
5235 func DescribeDnsGtmInstanceSystemCname(client *Client, request *DescribeDnsGtmInstanceSystemCnameRequest) (_result *DescribeDnsGtmInstanceSystemCnameResponse, _err error) {
5236 runtime := &dara.RuntimeOptions{}
5237 _result = &DescribeDnsGtmInstanceSystemCnameResponse{}
5238 _body, _err := DescribeDnsGtmInstanceSystemCnameWithOptions(client,request, runtime)
5239 if _err != nil {
5240 return _result, _err
5241 }
5242 _result = _body
5243 return _result, _err
5244 }
5245
5246 // Summary:
5247 //
5248 // Queries a list of instances.
5249 //
5250 // @param request - DescribeDnsGtmInstancesRequest
5251 //
5252 // @param runtime - runtime options for this request RuntimeOptions
5253 //
5254 // @return DescribeDnsGtmInstancesResponse
5255 func DescribeDnsGtmInstancesWithOptions(client *Client, request *DescribeDnsGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstancesResponse, _err error) {
5256 if dara.BoolValue(client.EnableValidate) == true {
5257 _err = request.Validate()
5258 if _err != nil {
5259 return _result, _err
5260 }
5261 }
5262 query := map[string]interface{}{}
5263 if !dara.IsNil(request.Keyword) {
5264 query["Keyword"] = request.Keyword
5265 }
5266
5267 if !dara.IsNil(request.Lang) {
5268 query["Lang"] = request.Lang
5269 }
5270
5271 if !dara.IsNil(request.PageNumber) {
5272 query["PageNumber"] = request.PageNumber
5273 }
5274
5275 if !dara.IsNil(request.PageSize) {
5276 query["PageSize"] = request.PageSize
5277 }
5278
5279 if !dara.IsNil(request.ResourceGroupId) {
5280 query["ResourceGroupId"] = request.ResourceGroupId
5281 }
5282
5283 req := &openapiutil.OpenApiRequest{
5284 Query: openapiutil.Query(query),
5285 }
5286 params := &openapiutil.Params{
5287 Action: dara.String("DescribeDnsGtmInstances"),
5288 Version: dara.String("2015-01-09"),
5289 Protocol: dara.String("HTTPS"),
5290 Pathname: dara.String("/"),
5291 Method: dara.String("POST"),
5292 AuthType: dara.String("AK"),
5293 Style: dara.String("RPC"),
5294 ReqBodyType: dara.String("formData"),
5295 BodyType: dara.String("json"),
5296 }
5297 _result = &DescribeDnsGtmInstancesResponse{}
5298 _body, _err := client.CallApi(params, req, runtime)
5299 if _err != nil {
5300 return _result, _err
5301 }
5302 _err = dara.Convert(_body, &_result)
5303 return _result, _err
5304 }
5305
5306 // Summary:
5307 //
5308 // Queries a list of instances.
5309 //
5310 // @param request - DescribeDnsGtmInstancesRequest
5311 //
5312 // @return DescribeDnsGtmInstancesResponse
5313 func DescribeDnsGtmInstances(client *Client, request *DescribeDnsGtmInstancesRequest) (_result *DescribeDnsGtmInstancesResponse, _err error) {
5314 runtime := &dara.RuntimeOptions{}
5315 _result = &DescribeDnsGtmInstancesResponse{}
5316 _body, _err := DescribeDnsGtmInstancesWithOptions(client,request, runtime)
5317 if _err != nil {
5318 return _result, _err
5319 }
5320 _result = _body
5321 return _result, _err
5322 }
5323
5324 // Summary:
5325 //
5326 // Queries operation logs of a Global Traffic Manager (GTM) instance.
5327 //
5328 // @param request - DescribeDnsGtmLogsRequest
5329 //
5330 // @param runtime - runtime options for this request RuntimeOptions
5331 //
5332 // @return DescribeDnsGtmLogsResponse
5333 func DescribeDnsGtmLogsWithOptions(client *Client, request *DescribeDnsGtmLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmLogsResponse, _err error) {
5334 if dara.BoolValue(client.EnableValidate) == true {
5335 _err = request.Validate()
5336 if _err != nil {
5337 return _result, _err
5338 }
5339 }
5340 query := map[string]interface{}{}
5341 if !dara.IsNil(request.EndTimestamp) {
5342 query["EndTimestamp"] = request.EndTimestamp
5343 }
5344
5345 if !dara.IsNil(request.InstanceId) {
5346 query["InstanceId"] = request.InstanceId
5347 }
5348
5349 if !dara.IsNil(request.Keyword) {
5350 query["Keyword"] = request.Keyword
5351 }
5352
5353 if !dara.IsNil(request.Lang) {
5354 query["Lang"] = request.Lang
5355 }
5356
5357 if !dara.IsNil(request.PageNumber) {
5358 query["PageNumber"] = request.PageNumber
5359 }
5360
5361 if !dara.IsNil(request.PageSize) {
5362 query["PageSize"] = request.PageSize
5363 }
5364
5365 if !dara.IsNil(request.StartTimestamp) {
5366 query["StartTimestamp"] = request.StartTimestamp
5367 }
5368
5369 req := &openapiutil.OpenApiRequest{
5370 Query: openapiutil.Query(query),
5371 }
5372 params := &openapiutil.Params{
5373 Action: dara.String("DescribeDnsGtmLogs"),
5374 Version: dara.String("2015-01-09"),
5375 Protocol: dara.String("HTTPS"),
5376 Pathname: dara.String("/"),
5377 Method: dara.String("POST"),
5378 AuthType: dara.String("AK"),
5379 Style: dara.String("RPC"),
5380 ReqBodyType: dara.String("formData"),
5381 BodyType: dara.String("json"),
5382 }
5383 _result = &DescribeDnsGtmLogsResponse{}
5384 _body, _err := client.CallApi(params, req, runtime)
5385 if _err != nil {
5386 return _result, _err
5387 }
5388 _err = dara.Convert(_body, &_result)
5389 return _result, _err
5390 }
5391
5392 // Summary:
5393 //
5394 // Queries operation logs of a Global Traffic Manager (GTM) instance.
5395 //
5396 // @param request - DescribeDnsGtmLogsRequest
5397 //
5398 // @return DescribeDnsGtmLogsResponse
5399 func DescribeDnsGtmLogs(client *Client, request *DescribeDnsGtmLogsRequest) (_result *DescribeDnsGtmLogsResponse, _err error) {
5400 runtime := &dara.RuntimeOptions{}
5401 _result = &DescribeDnsGtmLogsResponse{}
5402 _body, _err := DescribeDnsGtmLogsWithOptions(client,request, runtime)
5403 if _err != nil {
5404 return _result, _err
5405 }
5406 _result = _body
5407 return _result, _err
5408 }
5409
5410 // Summary:
5411 //
5412 // Queries the configuration items that can be set for a health check task.
5413 //
5414 // @param request - DescribeDnsGtmMonitorAvailableConfigRequest
5415 //
5416 // @param runtime - runtime options for this request RuntimeOptions
5417 //
5418 // @return DescribeDnsGtmMonitorAvailableConfigResponse
5419 func DescribeDnsGtmMonitorAvailableConfigWithOptions(client *Client, request *DescribeDnsGtmMonitorAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmMonitorAvailableConfigResponse, _err error) {
5420 if dara.BoolValue(client.EnableValidate) == true {
5421 _err = request.Validate()
5422 if _err != nil {
5423 return _result, _err
5424 }
5425 }
5426 query := map[string]interface{}{}
5427 if !dara.IsNil(request.Lang) {
5428 query["Lang"] = request.Lang
5429 }
5430
5431 req := &openapiutil.OpenApiRequest{
5432 Query: openapiutil.Query(query),
5433 }
5434 params := &openapiutil.Params{
5435 Action: dara.String("DescribeDnsGtmMonitorAvailableConfig"),
5436 Version: dara.String("2015-01-09"),
5437 Protocol: dara.String("HTTPS"),
5438 Pathname: dara.String("/"),
5439 Method: dara.String("POST"),
5440 AuthType: dara.String("AK"),
5441 Style: dara.String("RPC"),
5442 ReqBodyType: dara.String("formData"),
5443 BodyType: dara.String("json"),
5444 }
5445 _result = &DescribeDnsGtmMonitorAvailableConfigResponse{}
5446 _body, _err := client.CallApi(params, req, runtime)
5447 if _err != nil {
5448 return _result, _err
5449 }
5450 _err = dara.Convert(_body, &_result)
5451 return _result, _err
5452 }
5453
5454 // Summary:
5455 //
5456 // Queries the configuration items that can be set for a health check task.
5457 //
5458 // @param request - DescribeDnsGtmMonitorAvailableConfigRequest
5459 //
5460 // @return DescribeDnsGtmMonitorAvailableConfigResponse
5461 func DescribeDnsGtmMonitorAvailableConfig(client *Client, request *DescribeDnsGtmMonitorAvailableConfigRequest) (_result *DescribeDnsGtmMonitorAvailableConfigResponse, _err error) {
5462 runtime := &dara.RuntimeOptions{}
5463 _result = &DescribeDnsGtmMonitorAvailableConfigResponse{}
5464 _body, _err := DescribeDnsGtmMonitorAvailableConfigWithOptions(client,request, runtime)
5465 if _err != nil {
5466 return _result, _err
5467 }
5468 _result = _body
5469 return _result, _err
5470 }
5471
5472 // Summary:
5473 //
5474 // Queries the health check configuration of an address pool.
5475 //
5476 // @param request - DescribeDnsGtmMonitorConfigRequest
5477 //
5478 // @param runtime - runtime options for this request RuntimeOptions
5479 //
5480 // @return DescribeDnsGtmMonitorConfigResponse
5481 func DescribeDnsGtmMonitorConfigWithOptions(client *Client, request *DescribeDnsGtmMonitorConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmMonitorConfigResponse, _err error) {
5482 if dara.BoolValue(client.EnableValidate) == true {
5483 _err = request.Validate()
5484 if _err != nil {
5485 return _result, _err
5486 }
5487 }
5488 query := map[string]interface{}{}
5489 if !dara.IsNil(request.Lang) {
5490 query["Lang"] = request.Lang
5491 }
5492
5493 if !dara.IsNil(request.MonitorConfigId) {
5494 query["MonitorConfigId"] = request.MonitorConfigId
5495 }
5496
5497 req := &openapiutil.OpenApiRequest{
5498 Query: openapiutil.Query(query),
5499 }
5500 params := &openapiutil.Params{
5501 Action: dara.String("DescribeDnsGtmMonitorConfig"),
5502 Version: dara.String("2015-01-09"),
5503 Protocol: dara.String("HTTPS"),
5504 Pathname: dara.String("/"),
5505 Method: dara.String("POST"),
5506 AuthType: dara.String("AK"),
5507 Style: dara.String("RPC"),
5508 ReqBodyType: dara.String("formData"),
5509 BodyType: dara.String("json"),
5510 }
5511 _result = &DescribeDnsGtmMonitorConfigResponse{}
5512 _body, _err := client.CallApi(params, req, runtime)
5513 if _err != nil {
5514 return _result, _err
5515 }
5516 _err = dara.Convert(_body, &_result)
5517 return _result, _err
5518 }
5519
5520 // Summary:
5521 //
5522 // Queries the health check configuration of an address pool.
5523 //
5524 // @param request - DescribeDnsGtmMonitorConfigRequest
5525 //
5526 // @return DescribeDnsGtmMonitorConfigResponse
5527 func DescribeDnsGtmMonitorConfig(client *Client, request *DescribeDnsGtmMonitorConfigRequest) (_result *DescribeDnsGtmMonitorConfigResponse, _err error) {
5528 runtime := &dara.RuntimeOptions{}
5529 _result = &DescribeDnsGtmMonitorConfigResponse{}
5530 _body, _err := DescribeDnsGtmMonitorConfigWithOptions(client,request, runtime)
5531 if _err != nil {
5532 return _result, _err
5533 }
5534 _result = _body
5535 return _result, _err
5536 }
5537
5538 // Summary:
5539 //
5540 // Queries the details about a paid Alibaba Cloud DNS instance based on the instance ID.
5541 //
5542 // @param request - DescribeDnsProductInstanceRequest
5543 //
5544 // @param runtime - runtime options for this request RuntimeOptions
5545 //
5546 // @return DescribeDnsProductInstanceResponse
5547 func DescribeDnsProductInstanceWithOptions(client *Client, request *DescribeDnsProductInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsProductInstanceResponse, _err error) {
5548 if dara.BoolValue(client.EnableValidate) == true {
5549 _err = request.Validate()
5550 if _err != nil {
5551 return _result, _err
5552 }
5553 }
5554 query := map[string]interface{}{}
5555 if !dara.IsNil(request.InstanceId) {
5556 query["InstanceId"] = request.InstanceId
5557 }
5558
5559 if !dara.IsNil(request.Lang) {
5560 query["Lang"] = request.Lang
5561 }
5562
5563 if !dara.IsNil(request.UserClientIp) {
5564 query["UserClientIp"] = request.UserClientIp
5565 }
5566
5567 req := &openapiutil.OpenApiRequest{
5568 Query: openapiutil.Query(query),
5569 }
5570 params := &openapiutil.Params{
5571 Action: dara.String("DescribeDnsProductInstance"),
5572 Version: dara.String("2015-01-09"),
5573 Protocol: dara.String("HTTPS"),
5574 Pathname: dara.String("/"),
5575 Method: dara.String("POST"),
5576 AuthType: dara.String("AK"),
5577 Style: dara.String("RPC"),
5578 ReqBodyType: dara.String("formData"),
5579 BodyType: dara.String("json"),
5580 }
5581 _result = &DescribeDnsProductInstanceResponse{}
5582 _body, _err := client.CallApi(params, req, runtime)
5583 if _err != nil {
5584 return _result, _err
5585 }
5586 _err = dara.Convert(_body, &_result)
5587 return _result, _err
5588 }
5589
5590 // Summary:
5591 //
5592 // Queries the details about a paid Alibaba Cloud DNS instance based on the instance ID.
5593 //
5594 // @param request - DescribeDnsProductInstanceRequest
5595 //
5596 // @return DescribeDnsProductInstanceResponse
5597 func DescribeDnsProductInstance(client *Client, request *DescribeDnsProductInstanceRequest) (_result *DescribeDnsProductInstanceResponse, _err error) {
5598 runtime := &dara.RuntimeOptions{}
5599 _result = &DescribeDnsProductInstanceResponse{}
5600 _body, _err := DescribeDnsProductInstanceWithOptions(client,request, runtime)
5601 if _err != nil {
5602 return _result, _err
5603 }
5604 _result = _body
5605 return _result, _err
5606 }
5607
5608 // Summary:
5609 //
5610 // Calls the DescribeDnsProductInstances operation to query the list of paid Alibaba Cloud DNS instances based on input parameters.
5611 //
5612 // Description:
5613 //
5614 // > If the response parameters of an Alibaba Cloud DNS instance do not contain domain names, no domain names are bound to the instance.
5615 //
5616 // @param request - DescribeDnsProductInstancesRequest
5617 //
5618 // @param runtime - runtime options for this request RuntimeOptions
5619 //
5620 // @return DescribeDnsProductInstancesResponse
5621 func DescribeDnsProductInstancesWithOptions(client *Client, request *DescribeDnsProductInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsProductInstancesResponse, _err error) {
5622 if dara.BoolValue(client.EnableValidate) == true {
5623 _err = request.Validate()
5624 if _err != nil {
5625 return _result, _err
5626 }
5627 }
5628 query := map[string]interface{}{}
5629 if !dara.IsNil(request.Direction) {
5630 query["Direction"] = request.Direction
5631 }
5632
5633 if !dara.IsNil(request.DomainType) {
5634 query["DomainType"] = request.DomainType
5635 }
5636
5637 if !dara.IsNil(request.Lang) {
5638 query["Lang"] = request.Lang
5639 }
5640
5641 if !dara.IsNil(request.OrderBy) {
5642 query["OrderBy"] = request.OrderBy
5643 }
5644
5645 if !dara.IsNil(request.PageNumber) {
5646 query["PageNumber"] = request.PageNumber
5647 }
5648
5649 if !dara.IsNil(request.PageSize) {
5650 query["PageSize"] = request.PageSize
5651 }
5652
5653 if !dara.IsNil(request.UserClientIp) {
5654 query["UserClientIp"] = request.UserClientIp
5655 }
5656
5657 if !dara.IsNil(request.VersionCode) {
5658 query["VersionCode"] = request.VersionCode
5659 }
5660
5661 req := &openapiutil.OpenApiRequest{
5662 Query: openapiutil.Query(query),
5663 }
5664 params := &openapiutil.Params{
5665 Action: dara.String("DescribeDnsProductInstances"),
5666 Version: dara.String("2015-01-09"),
5667 Protocol: dara.String("HTTPS"),
5668 Pathname: dara.String("/"),
5669 Method: dara.String("POST"),
5670 AuthType: dara.String("AK"),
5671 Style: dara.String("RPC"),
5672 ReqBodyType: dara.String("formData"),
5673 BodyType: dara.String("json"),
5674 }
5675 _result = &DescribeDnsProductInstancesResponse{}
5676 _body, _err := client.CallApi(params, req, runtime)
5677 if _err != nil {
5678 return _result, _err
5679 }
5680 _err = dara.Convert(_body, &_result)
5681 return _result, _err
5682 }
5683
5684 // Summary:
5685 //
5686 // Calls the DescribeDnsProductInstances operation to query the list of paid Alibaba Cloud DNS instances based on input parameters.
5687 //
5688 // Description:
5689 //
5690 // > If the response parameters of an Alibaba Cloud DNS instance do not contain domain names, no domain names are bound to the instance.
5691 //
5692 // @param request - DescribeDnsProductInstancesRequest
5693 //
5694 // @return DescribeDnsProductInstancesResponse
5695 func DescribeDnsProductInstances(client *Client, request *DescribeDnsProductInstancesRequest) (_result *DescribeDnsProductInstancesResponse, _err error) {
5696 runtime := &dara.RuntimeOptions{}
5697 _result = &DescribeDnsProductInstancesResponse{}
5698 _body, _err := DescribeDnsProductInstancesWithOptions(client,request, runtime)
5699 if _err != nil {
5700 return _result, _err
5701 }
5702 _result = _body
5703 return _result, _err
5704 }
5705
5706 // @param request - DescribeDohAccountStatisticsRequest
5707 //
5708 // @param runtime - runtime options for this request RuntimeOptions
5709 //
5710 // @return DescribeDohAccountStatisticsResponse
5711 func DescribeDohAccountStatisticsWithOptions(client *Client, request *DescribeDohAccountStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohAccountStatisticsResponse, _err error) {
5712 if dara.BoolValue(client.EnableValidate) == true {
5713 _err = request.Validate()
5714 if _err != nil {
5715 return _result, _err
5716 }
5717 }
5718 query := map[string]interface{}{}
5719 if !dara.IsNil(request.EndDate) {
5720 query["EndDate"] = request.EndDate
5721 }
5722
5723 if !dara.IsNil(request.Lang) {
5724 query["Lang"] = request.Lang
5725 }
5726
5727 if !dara.IsNil(request.StartDate) {
5728 query["StartDate"] = request.StartDate
5729 }
5730
5731 req := &openapiutil.OpenApiRequest{
5732 Query: openapiutil.Query(query),
5733 }
5734 params := &openapiutil.Params{
5735 Action: dara.String("DescribeDohAccountStatistics"),
5736 Version: dara.String("2015-01-09"),
5737 Protocol: dara.String("HTTPS"),
5738 Pathname: dara.String("/"),
5739 Method: dara.String("POST"),
5740 AuthType: dara.String("AK"),
5741 Style: dara.String("RPC"),
5742 ReqBodyType: dara.String("formData"),
5743 BodyType: dara.String("json"),
5744 }
5745 _result = &DescribeDohAccountStatisticsResponse{}
5746 _body, _err := client.CallApi(params, req, runtime)
5747 if _err != nil {
5748 return _result, _err
5749 }
5750 _err = dara.Convert(_body, &_result)
5751 return _result, _err
5752 }
5753
5754 // @param request - DescribeDohAccountStatisticsRequest
5755 //
5756 // @return DescribeDohAccountStatisticsResponse
5757 func DescribeDohAccountStatistics(client *Client, request *DescribeDohAccountStatisticsRequest) (_result *DescribeDohAccountStatisticsResponse, _err error) {
5758 runtime := &dara.RuntimeOptions{}
5759 _result = &DescribeDohAccountStatisticsResponse{}
5760 _body, _err := DescribeDohAccountStatisticsWithOptions(client,request, runtime)
5761 if _err != nil {
5762 return _result, _err
5763 }
5764 _result = _body
5765 return _result, _err
5766 }
5767
5768 // Summary:
5769 //
5770 // 查询DOH域名请求量数据
5771 //
5772 // @param request - DescribeDohDomainStatisticsRequest
5773 //
5774 // @param runtime - runtime options for this request RuntimeOptions
5775 //
5776 // @return DescribeDohDomainStatisticsResponse
5777 func DescribeDohDomainStatisticsWithOptions(client *Client, request *DescribeDohDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohDomainStatisticsResponse, _err error) {
5778 if dara.BoolValue(client.EnableValidate) == true {
5779 _err = request.Validate()
5780 if _err != nil {
5781 return _result, _err
5782 }
5783 }
5784 query := map[string]interface{}{}
5785 if !dara.IsNil(request.DomainName) {
5786 query["DomainName"] = request.DomainName
5787 }
5788
5789 if !dara.IsNil(request.EndDate) {
5790 query["EndDate"] = request.EndDate
5791 }
5792
5793 if !dara.IsNil(request.Lang) {
5794 query["Lang"] = request.Lang
5795 }
5796
5797 if !dara.IsNil(request.StartDate) {
5798 query["StartDate"] = request.StartDate
5799 }
5800
5801 req := &openapiutil.OpenApiRequest{
5802 Query: openapiutil.Query(query),
5803 }
5804 params := &openapiutil.Params{
5805 Action: dara.String("DescribeDohDomainStatistics"),
5806 Version: dara.String("2015-01-09"),
5807 Protocol: dara.String("HTTPS"),
5808 Pathname: dara.String("/"),
5809 Method: dara.String("POST"),
5810 AuthType: dara.String("AK"),
5811 Style: dara.String("RPC"),
5812 ReqBodyType: dara.String("formData"),
5813 BodyType: dara.String("json"),
5814 }
5815 _result = &DescribeDohDomainStatisticsResponse{}
5816 _body, _err := client.CallApi(params, req, runtime)
5817 if _err != nil {
5818 return _result, _err
5819 }
5820 _err = dara.Convert(_body, &_result)
5821 return _result, _err
5822 }
5823
5824 // Summary:
5825 //
5826 // 查询DOH域名请求量数据
5827 //
5828 // @param request - DescribeDohDomainStatisticsRequest
5829 //
5830 // @return DescribeDohDomainStatisticsResponse
5831 func DescribeDohDomainStatistics(client *Client, request *DescribeDohDomainStatisticsRequest) (_result *DescribeDohDomainStatisticsResponse, _err error) {
5832 runtime := &dara.RuntimeOptions{}
5833 _result = &DescribeDohDomainStatisticsResponse{}
5834 _body, _err := DescribeDohDomainStatisticsWithOptions(client,request, runtime)
5835 if _err != nil {
5836 return _result, _err
5837 }
5838 _result = _body
5839 return _result, _err
5840 }
5841
5842 // @param request - DescribeDohDomainStatisticsSummaryRequest
5843 //
5844 // @param runtime - runtime options for this request RuntimeOptions
5845 //
5846 // @return DescribeDohDomainStatisticsSummaryResponse
5847 func DescribeDohDomainStatisticsSummaryWithOptions(client *Client, request *DescribeDohDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohDomainStatisticsSummaryResponse, _err error) {
5848 if dara.BoolValue(client.EnableValidate) == true {
5849 _err = request.Validate()
5850 if _err != nil {
5851 return _result, _err
5852 }
5853 }
5854 query := map[string]interface{}{}
5855 if !dara.IsNil(request.DomainName) {
5856 query["DomainName"] = request.DomainName
5857 }
5858
5859 if !dara.IsNil(request.EndDate) {
5860 query["EndDate"] = request.EndDate
5861 }
5862
5863 if !dara.IsNil(request.Lang) {
5864 query["Lang"] = request.Lang
5865 }
5866
5867 if !dara.IsNil(request.PageNumber) {
5868 query["PageNumber"] = request.PageNumber
5869 }
5870
5871 if !dara.IsNil(request.PageSize) {
5872 query["PageSize"] = request.PageSize
5873 }
5874
5875 if !dara.IsNil(request.StartDate) {
5876 query["StartDate"] = request.StartDate
5877 }
5878
5879 req := &openapiutil.OpenApiRequest{
5880 Query: openapiutil.Query(query),
5881 }
5882 params := &openapiutil.Params{
5883 Action: dara.String("DescribeDohDomainStatisticsSummary"),
5884 Version: dara.String("2015-01-09"),
5885 Protocol: dara.String("HTTPS"),
5886 Pathname: dara.String("/"),
5887 Method: dara.String("POST"),
5888 AuthType: dara.String("AK"),
5889 Style: dara.String("RPC"),
5890 ReqBodyType: dara.String("formData"),
5891 BodyType: dara.String("json"),
5892 }
5893 _result = &DescribeDohDomainStatisticsSummaryResponse{}
5894 _body, _err := client.CallApi(params, req, runtime)
5895 if _err != nil {
5896 return _result, _err
5897 }
5898 _err = dara.Convert(_body, &_result)
5899 return _result, _err
5900 }
5901
5902 // @param request - DescribeDohDomainStatisticsSummaryRequest
5903 //
5904 // @return DescribeDohDomainStatisticsSummaryResponse
5905 func DescribeDohDomainStatisticsSummary(client *Client, request *DescribeDohDomainStatisticsSummaryRequest) (_result *DescribeDohDomainStatisticsSummaryResponse, _err error) {
5906 runtime := &dara.RuntimeOptions{}
5907 _result = &DescribeDohDomainStatisticsSummaryResponse{}
5908 _body, _err := DescribeDohDomainStatisticsSummaryWithOptions(client,request, runtime)
5909 if _err != nil {
5910 return _result, _err
5911 }
5912 _result = _body
5913 return _result, _err
5914 }
5915
5916 // @param request - DescribeDohSubDomainStatisticsRequest
5917 //
5918 // @param runtime - runtime options for this request RuntimeOptions
5919 //
5920 // @return DescribeDohSubDomainStatisticsResponse
5921 func DescribeDohSubDomainStatisticsWithOptions(client *Client, request *DescribeDohSubDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohSubDomainStatisticsResponse, _err error) {
5922 if dara.BoolValue(client.EnableValidate) == true {
5923 _err = request.Validate()
5924 if _err != nil {
5925 return _result, _err
5926 }
5927 }
5928 query := map[string]interface{}{}
5929 if !dara.IsNil(request.EndDate) {
5930 query["EndDate"] = request.EndDate
5931 }
5932
5933 if !dara.IsNil(request.Lang) {
5934 query["Lang"] = request.Lang
5935 }
5936
5937 if !dara.IsNil(request.StartDate) {
5938 query["StartDate"] = request.StartDate
5939 }
5940
5941 if !dara.IsNil(request.SubDomain) {
5942 query["SubDomain"] = request.SubDomain
5943 }
5944
5945 req := &openapiutil.OpenApiRequest{
5946 Query: openapiutil.Query(query),
5947 }
5948 params := &openapiutil.Params{
5949 Action: dara.String("DescribeDohSubDomainStatistics"),
5950 Version: dara.String("2015-01-09"),
5951 Protocol: dara.String("HTTPS"),
5952 Pathname: dara.String("/"),
5953 Method: dara.String("POST"),
5954 AuthType: dara.String("AK"),
5955 Style: dara.String("RPC"),
5956 ReqBodyType: dara.String("formData"),
5957 BodyType: dara.String("json"),
5958 }
5959 _result = &DescribeDohSubDomainStatisticsResponse{}
5960 _body, _err := client.CallApi(params, req, runtime)
5961 if _err != nil {
5962 return _result, _err
5963 }
5964 _err = dara.Convert(_body, &_result)
5965 return _result, _err
5966 }
5967
5968 // @param request - DescribeDohSubDomainStatisticsRequest
5969 //
5970 // @return DescribeDohSubDomainStatisticsResponse
5971 func DescribeDohSubDomainStatistics(client *Client, request *DescribeDohSubDomainStatisticsRequest) (_result *DescribeDohSubDomainStatisticsResponse, _err error) {
5972 runtime := &dara.RuntimeOptions{}
5973 _result = &DescribeDohSubDomainStatisticsResponse{}
5974 _body, _err := DescribeDohSubDomainStatisticsWithOptions(client,request, runtime)
5975 if _err != nil {
5976 return _result, _err
5977 }
5978 _result = _body
5979 return _result, _err
5980 }
5981
5982 // @param request - DescribeDohSubDomainStatisticsSummaryRequest
5983 //
5984 // @param runtime - runtime options for this request RuntimeOptions
5985 //
5986 // @return DescribeDohSubDomainStatisticsSummaryResponse
5987 func DescribeDohSubDomainStatisticsSummaryWithOptions(client *Client, request *DescribeDohSubDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohSubDomainStatisticsSummaryResponse, _err error) {
5988 if dara.BoolValue(client.EnableValidate) == true {
5989 _err = request.Validate()
5990 if _err != nil {
5991 return _result, _err
5992 }
5993 }
5994 query := map[string]interface{}{}
5995 if !dara.IsNil(request.DomainName) {
5996 query["DomainName"] = request.DomainName
5997 }
5998
5999 if !dara.IsNil(request.EndDate) {
6000 query["EndDate"] = request.EndDate
6001 }
6002
6003 if !dara.IsNil(request.Lang) {
6004 query["Lang"] = request.Lang
6005 }
6006
6007 if !dara.IsNil(request.PageNumber) {
6008 query["PageNumber"] = request.PageNumber
6009 }
6010
6011 if !dara.IsNil(request.PageSize) {
6012 query["PageSize"] = request.PageSize
6013 }
6014
6015 if !dara.IsNil(request.StartDate) {
6016 query["StartDate"] = request.StartDate
6017 }
6018
6019 if !dara.IsNil(request.SubDomain) {
6020 query["SubDomain"] = request.SubDomain
6021 }
6022
6023 req := &openapiutil.OpenApiRequest{
6024 Query: openapiutil.Query(query),
6025 }
6026 params := &openapiutil.Params{
6027 Action: dara.String("DescribeDohSubDomainStatisticsSummary"),
6028 Version: dara.String("2015-01-09"),
6029 Protocol: dara.String("HTTPS"),
6030 Pathname: dara.String("/"),
6031 Method: dara.String("POST"),
6032 AuthType: dara.String("AK"),
6033 Style: dara.String("RPC"),
6034 ReqBodyType: dara.String("formData"),
6035 BodyType: dara.String("json"),
6036 }
6037 _result = &DescribeDohSubDomainStatisticsSummaryResponse{}
6038 _body, _err := client.CallApi(params, req, runtime)
6039 if _err != nil {
6040 return _result, _err
6041 }
6042 _err = dara.Convert(_body, &_result)
6043 return _result, _err
6044 }
6045
6046 // @param request - DescribeDohSubDomainStatisticsSummaryRequest
6047 //
6048 // @return DescribeDohSubDomainStatisticsSummaryResponse
6049 func DescribeDohSubDomainStatisticsSummary(client *Client, request *DescribeDohSubDomainStatisticsSummaryRequest) (_result *DescribeDohSubDomainStatisticsSummaryResponse, _err error) {
6050 runtime := &dara.RuntimeOptions{}
6051 _result = &DescribeDohSubDomainStatisticsSummaryResponse{}
6052 _body, _err := DescribeDohSubDomainStatisticsSummaryWithOptions(client,request, runtime)
6053 if _err != nil {
6054 return _result, _err
6055 }
6056 _result = _body
6057 return _result, _err
6058 }
6059
6060 // Summary:
6061 //
6062 // Queries the numbers of accessed domains and subdomains by using DNS over HTTPS (DoH).
6063 //
6064 // @param request - DescribeDohUserInfoRequest
6065 //
6066 // @param runtime - runtime options for this request RuntimeOptions
6067 //
6068 // @return DescribeDohUserInfoResponse
6069 func DescribeDohUserInfoWithOptions(client *Client, request *DescribeDohUserInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohUserInfoResponse, _err error) {
6070 if dara.BoolValue(client.EnableValidate) == true {
6071 _err = request.Validate()
6072 if _err != nil {
6073 return _result, _err
6074 }
6075 }
6076 query := map[string]interface{}{}
6077 if !dara.IsNil(request.EndDate) {
6078 query["EndDate"] = request.EndDate
6079 }
6080
6081 if !dara.IsNil(request.Lang) {
6082 query["Lang"] = request.Lang
6083 }
6084
6085 if !dara.IsNil(request.StartDate) {
6086 query["StartDate"] = request.StartDate
6087 }
6088
6089 req := &openapiutil.OpenApiRequest{
6090 Query: openapiutil.Query(query),
6091 }
6092 params := &openapiutil.Params{
6093 Action: dara.String("DescribeDohUserInfo"),
6094 Version: dara.String("2015-01-09"),
6095 Protocol: dara.String("HTTPS"),
6096 Pathname: dara.String("/"),
6097 Method: dara.String("POST"),
6098 AuthType: dara.String("AK"),
6099 Style: dara.String("RPC"),
6100 ReqBodyType: dara.String("formData"),
6101 BodyType: dara.String("json"),
6102 }
6103 _result = &DescribeDohUserInfoResponse{}
6104 _body, _err := client.CallApi(params, req, runtime)
6105 if _err != nil {
6106 return _result, _err
6107 }
6108 _err = dara.Convert(_body, &_result)
6109 return _result, _err
6110 }
6111
6112 // Summary:
6113 //
6114 // Queries the numbers of accessed domains and subdomains by using DNS over HTTPS (DoH).
6115 //
6116 // @param request - DescribeDohUserInfoRequest
6117 //
6118 // @return DescribeDohUserInfoResponse
6119 func DescribeDohUserInfo(client *Client, request *DescribeDohUserInfoRequest) (_result *DescribeDohUserInfoResponse, _err error) {
6120 runtime := &dara.RuntimeOptions{}
6121 _result = &DescribeDohUserInfoResponse{}
6122 _body, _err := DescribeDohUserInfoWithOptions(client,request, runtime)
6123 if _err != nil {
6124 return _result, _err
6125 }
6126 _result = _body
6127 return _result, _err
6128 }
6129
6130 // Summary:
6131 //
6132 // Queries the Domain Name System Security Extensions (DNSSEC) configurations of a domain name based on the specified parameters.
6133 //
6134 // @param request - DescribeDomainDnssecInfoRequest
6135 //
6136 // @param runtime - runtime options for this request RuntimeOptions
6137 //
6138 // @return DescribeDomainDnssecInfoResponse
6139 func DescribeDomainDnssecInfoWithOptions(client *Client, request *DescribeDomainDnssecInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainDnssecInfoResponse, _err error) {
6140 if dara.BoolValue(client.EnableValidate) == true {
6141 _err = request.Validate()
6142 if _err != nil {
6143 return _result, _err
6144 }
6145 }
6146 query := map[string]interface{}{}
6147 if !dara.IsNil(request.DomainName) {
6148 query["DomainName"] = request.DomainName
6149 }
6150
6151 if !dara.IsNil(request.Lang) {
6152 query["Lang"] = request.Lang
6153 }
6154
6155 req := &openapiutil.OpenApiRequest{
6156 Query: openapiutil.Query(query),
6157 }
6158 params := &openapiutil.Params{
6159 Action: dara.String("DescribeDomainDnssecInfo"),
6160 Version: dara.String("2015-01-09"),
6161 Protocol: dara.String("HTTPS"),
6162 Pathname: dara.String("/"),
6163 Method: dara.String("POST"),
6164 AuthType: dara.String("AK"),
6165 Style: dara.String("RPC"),
6166 ReqBodyType: dara.String("formData"),
6167 BodyType: dara.String("json"),
6168 }
6169 _result = &DescribeDomainDnssecInfoResponse{}
6170 _body, _err := client.CallApi(params, req, runtime)
6171 if _err != nil {
6172 return _result, _err
6173 }
6174 _err = dara.Convert(_body, &_result)
6175 return _result, _err
6176 }
6177
6178 // Summary:
6179 //
6180 // Queries the Domain Name System Security Extensions (DNSSEC) configurations of a domain name based on the specified parameters.
6181 //
6182 // @param request - DescribeDomainDnssecInfoRequest
6183 //
6184 // @return DescribeDomainDnssecInfoResponse
6185 func DescribeDomainDnssecInfo(client *Client, request *DescribeDomainDnssecInfoRequest) (_result *DescribeDomainDnssecInfoResponse, _err error) {
6186 runtime := &dara.RuntimeOptions{}
6187 _result = &DescribeDomainDnssecInfoResponse{}
6188 _body, _err := DescribeDomainDnssecInfoWithOptions(client,request, runtime)
6189 if _err != nil {
6190 return _result, _err
6191 }
6192 _result = _body
6193 return _result, _err
6194 }
6195
6196 // Summary:
6197 //
6198 // Queries all domain name groups based on the specified parameters.
6199 //
6200 // @param request - DescribeDomainGroupsRequest
6201 //
6202 // @param runtime - runtime options for this request RuntimeOptions
6203 //
6204 // @return DescribeDomainGroupsResponse
6205 func DescribeDomainGroupsWithOptions(client *Client, request *DescribeDomainGroupsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainGroupsResponse, _err error) {
6206 if dara.BoolValue(client.EnableValidate) == true {
6207 _err = request.Validate()
6208 if _err != nil {
6209 return _result, _err
6210 }
6211 }
6212 query := map[string]interface{}{}
6213 if !dara.IsNil(request.KeyWord) {
6214 query["KeyWord"] = request.KeyWord
6215 }
6216
6217 if !dara.IsNil(request.Lang) {
6218 query["Lang"] = request.Lang
6219 }
6220
6221 if !dara.IsNil(request.PageNumber) {
6222 query["PageNumber"] = request.PageNumber
6223 }
6224
6225 if !dara.IsNil(request.PageSize) {
6226 query["PageSize"] = request.PageSize
6227 }
6228
6229 req := &openapiutil.OpenApiRequest{
6230 Query: openapiutil.Query(query),
6231 }
6232 params := &openapiutil.Params{
6233 Action: dara.String("DescribeDomainGroups"),
6234 Version: dara.String("2015-01-09"),
6235 Protocol: dara.String("HTTPS"),
6236 Pathname: dara.String("/"),
6237 Method: dara.String("POST"),
6238 AuthType: dara.String("AK"),
6239 Style: dara.String("RPC"),
6240 ReqBodyType: dara.String("formData"),
6241 BodyType: dara.String("json"),
6242 }
6243 _result = &DescribeDomainGroupsResponse{}
6244 _body, _err := client.CallApi(params, req, runtime)
6245 if _err != nil {
6246 return _result, _err
6247 }
6248 _err = dara.Convert(_body, &_result)
6249 return _result, _err
6250 }
6251
6252 // Summary:
6253 //
6254 // Queries all domain name groups based on the specified parameters.
6255 //
6256 // @param request - DescribeDomainGroupsRequest
6257 //
6258 // @return DescribeDomainGroupsResponse
6259 func DescribeDomainGroups(client *Client, request *DescribeDomainGroupsRequest) (_result *DescribeDomainGroupsResponse, _err error) {
6260 runtime := &dara.RuntimeOptions{}
6261 _result = &DescribeDomainGroupsResponse{}
6262 _body, _err := DescribeDomainGroupsWithOptions(client,request, runtime)
6263 if _err != nil {
6264 return _result, _err
6265 }
6266 _result = _body
6267 return _result, _err
6268 }
6269
6270 // Summary:
6271 //
6272 // Queries the information about a domain name based on specified parameters.
6273 //
6274 // Description:
6275 //
6276 // In this example, the domain name is bound to an instance of Alibaba Cloud DNS Enterprise Ultimate Edition. For more information about valid Domain Name System (DNS) request lines, see the return values of the RecordLines parameter.
6277 //
6278 // @param request - DescribeDomainInfoRequest
6279 //
6280 // @param runtime - runtime options for this request RuntimeOptions
6281 //
6282 // @return DescribeDomainInfoResponse
6283 func DescribeDomainInfoWithOptions(client *Client, request *DescribeDomainInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainInfoResponse, _err error) {
6284 if dara.BoolValue(client.EnableValidate) == true {
6285 _err = request.Validate()
6286 if _err != nil {
6287 return _result, _err
6288 }
6289 }
6290 query := map[string]interface{}{}
6291 if !dara.IsNil(request.DomainName) {
6292 query["DomainName"] = request.DomainName
6293 }
6294
6295 if !dara.IsNil(request.Lang) {
6296 query["Lang"] = request.Lang
6297 }
6298
6299 if !dara.IsNil(request.NeedDetailAttributes) {
6300 query["NeedDetailAttributes"] = request.NeedDetailAttributes
6301 }
6302
6303 req := &openapiutil.OpenApiRequest{
6304 Query: openapiutil.Query(query),
6305 }
6306 params := &openapiutil.Params{
6307 Action: dara.String("DescribeDomainInfo"),
6308 Version: dara.String("2015-01-09"),
6309 Protocol: dara.String("HTTPS"),
6310 Pathname: dara.String("/"),
6311 Method: dara.String("POST"),
6312 AuthType: dara.String("AK"),
6313 Style: dara.String("RPC"),
6314 ReqBodyType: dara.String("formData"),
6315 BodyType: dara.String("json"),
6316 }
6317 _result = &DescribeDomainInfoResponse{}
6318 _body, _err := client.CallApi(params, req, runtime)
6319 if _err != nil {
6320 return _result, _err
6321 }
6322 _err = dara.Convert(_body, &_result)
6323 return _result, _err
6324 }
6325
6326 // Summary:
6327 //
6328 // Queries the information about a domain name based on specified parameters.
6329 //
6330 // Description:
6331 //
6332 // In this example, the domain name is bound to an instance of Alibaba Cloud DNS Enterprise Ultimate Edition. For more information about valid Domain Name System (DNS) request lines, see the return values of the RecordLines parameter.
6333 //
6334 // @param request - DescribeDomainInfoRequest
6335 //
6336 // @return DescribeDomainInfoResponse
6337 func DescribeDomainInfo(client *Client, request *DescribeDomainInfoRequest) (_result *DescribeDomainInfoResponse, _err error) {
6338 runtime := &dara.RuntimeOptions{}
6339 _result = &DescribeDomainInfoResponse{}
6340 _body, _err := DescribeDomainInfoWithOptions(client,request, runtime)
6341 if _err != nil {
6342 return _result, _err
6343 }
6344 _result = _body
6345 return _result, _err
6346 }
6347
6348 // Summary:
6349 //
6350 // Queries the operation logs of domain names based on the specified parameters.
6351 //
6352 // @param request - DescribeDomainLogsRequest
6353 //
6354 // @param runtime - runtime options for this request RuntimeOptions
6355 //
6356 // @return DescribeDomainLogsResponse
6357 func DescribeDomainLogsWithOptions(client *Client, request *DescribeDomainLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainLogsResponse, _err error) {
6358 if dara.BoolValue(client.EnableValidate) == true {
6359 _err = request.Validate()
6360 if _err != nil {
6361 return _result, _err
6362 }
6363 }
6364 query := map[string]interface{}{}
6365 if !dara.IsNil(request.GroupId) {
6366 query["GroupId"] = request.GroupId
6367 }
6368
6369 if !dara.IsNil(request.KeyWord) {
6370 query["KeyWord"] = request.KeyWord
6371 }
6372
6373 if !dara.IsNil(request.Lang) {
6374 query["Lang"] = request.Lang
6375 }
6376
6377 if !dara.IsNil(request.PageNumber) {
6378 query["PageNumber"] = request.PageNumber
6379 }
6380
6381 if !dara.IsNil(request.PageSize) {
6382 query["PageSize"] = request.PageSize
6383 }
6384
6385 if !dara.IsNil(request.StartDate) {
6386 query["StartDate"] = request.StartDate
6387 }
6388
6389 if !dara.IsNil(request.Type) {
6390 query["Type"] = request.Type
6391 }
6392
6393 if !dara.IsNil(request.EndDate) {
6394 query["endDate"] = request.EndDate
6395 }
6396
6397 req := &openapiutil.OpenApiRequest{
6398 Query: openapiutil.Query(query),
6399 }
6400 params := &openapiutil.Params{
6401 Action: dara.String("DescribeDomainLogs"),
6402 Version: dara.String("2015-01-09"),
6403 Protocol: dara.String("HTTPS"),
6404 Pathname: dara.String("/"),
6405 Method: dara.String("POST"),
6406 AuthType: dara.String("AK"),
6407 Style: dara.String("RPC"),
6408 ReqBodyType: dara.String("formData"),
6409 BodyType: dara.String("json"),
6410 }
6411 _result = &DescribeDomainLogsResponse{}
6412 _body, _err := client.CallApi(params, req, runtime)
6413 if _err != nil {
6414 return _result, _err
6415 }
6416 _err = dara.Convert(_body, &_result)
6417 return _result, _err
6418 }
6419
6420 // Summary:
6421 //
6422 // Queries the operation logs of domain names based on the specified parameters.
6423 //
6424 // @param request - DescribeDomainLogsRequest
6425 //
6426 // @return DescribeDomainLogsResponse
6427 func DescribeDomainLogs(client *Client, request *DescribeDomainLogsRequest) (_result *DescribeDomainLogsResponse, _err error) {
6428 runtime := &dara.RuntimeOptions{}
6429 _result = &DescribeDomainLogsResponse{}
6430 _body, _err := DescribeDomainLogsWithOptions(client,request, runtime)
6431 if _err != nil {
6432 return _result, _err
6433 }
6434 _result = _body
6435 return _result, _err
6436 }
6437
6438 // Summary:
6439 //
6440 // Queries the name servers configured for a specified domain name and checks whether all the name servers are Alibaba Cloud Domain Name System (DNS) servers.
6441 //
6442 // Description:
6443 //
6444 // > You can call this operation to query the authoritative servers of a domain name registry to obtain the name servers for a domain name. If the domain name is in an invalid state, such as serverHold or clientHold, an error may be returned.
6445 //
6446 // @param request - DescribeDomainNsRequest
6447 //
6448 // @param runtime - runtime options for this request RuntimeOptions
6449 //
6450 // @return DescribeDomainNsResponse
6451 func DescribeDomainNsWithOptions(client *Client, request *DescribeDomainNsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainNsResponse, _err error) {
6452 if dara.BoolValue(client.EnableValidate) == true {
6453 _err = request.Validate()
6454 if _err != nil {
6455 return _result, _err
6456 }
6457 }
6458 query := map[string]interface{}{}
6459 if !dara.IsNil(request.DomainName) {
6460 query["DomainName"] = request.DomainName
6461 }
6462
6463 if !dara.IsNil(request.Lang) {
6464 query["Lang"] = request.Lang
6465 }
6466
6467 req := &openapiutil.OpenApiRequest{
6468 Query: openapiutil.Query(query),
6469 }
6470 params := &openapiutil.Params{
6471 Action: dara.String("DescribeDomainNs"),
6472 Version: dara.String("2015-01-09"),
6473 Protocol: dara.String("HTTPS"),
6474 Pathname: dara.String("/"),
6475 Method: dara.String("POST"),
6476 AuthType: dara.String("AK"),
6477 Style: dara.String("RPC"),
6478 ReqBodyType: dara.String("formData"),
6479 BodyType: dara.String("json"),
6480 }
6481 _result = &DescribeDomainNsResponse{}
6482 _body, _err := client.CallApi(params, req, runtime)
6483 if _err != nil {
6484 return _result, _err
6485 }
6486 _err = dara.Convert(_body, &_result)
6487 return _result, _err
6488 }
6489
6490 // Summary:
6491 //
6492 // Queries the name servers configured for a specified domain name and checks whether all the name servers are Alibaba Cloud Domain Name System (DNS) servers.
6493 //
6494 // Description:
6495 //
6496 // > You can call this operation to query the authoritative servers of a domain name registry to obtain the name servers for a domain name. If the domain name is in an invalid state, such as serverHold or clientHold, an error may be returned.
6497 //
6498 // @param request - DescribeDomainNsRequest
6499 //
6500 // @return DescribeDomainNsResponse
6501 func DescribeDomainNs(client *Client, request *DescribeDomainNsRequest) (_result *DescribeDomainNsResponse, _err error) {
6502 runtime := &dara.RuntimeOptions{}
6503 _result = &DescribeDomainNsResponse{}
6504 _body, _err := DescribeDomainNsWithOptions(client,request, runtime)
6505 if _err != nil {
6506 return _result, _err
6507 }
6508 _result = _body
6509 return _result, _err
6510 }
6511
6512 // Summary:
6513 //
6514 // Queries the information about a Domain Name System (DNS) record by the ID of the DNS record.
6515 //
6516 // Description:
6517 //
6518 // ## Debugging
6519 //
6520 // [OpenAPI Explorer automatically calculates the signature value. For your convenience, we recommend that you call this operation in OpenAPI Explorer. OpenAPI Explorer dynamically generates the sample code of the operation for different SDKs.](https://api.aliyun.com/#product=Alidns\\&api=DescribeDomainRecordInfo\\&type=RPC\\&version=2015-01-09)
6521 //
6522 // @param request - DescribeDomainRecordInfoRequest
6523 //
6524 // @param runtime - runtime options for this request RuntimeOptions
6525 //
6526 // @return DescribeDomainRecordInfoResponse
6527 func DescribeDomainRecordInfoWithOptions(client *Client, request *DescribeDomainRecordInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainRecordInfoResponse, _err error) {
6528 if dara.BoolValue(client.EnableValidate) == true {
6529 _err = request.Validate()
6530 if _err != nil {
6531 return _result, _err
6532 }
6533 }
6534 query := map[string]interface{}{}
6535 if !dara.IsNil(request.Lang) {
6536 query["Lang"] = request.Lang
6537 }
6538
6539 if !dara.IsNil(request.RecordId) {
6540 query["RecordId"] = request.RecordId
6541 }
6542
6543 if !dara.IsNil(request.UserClientIp) {
6544 query["UserClientIp"] = request.UserClientIp
6545 }
6546
6547 req := &openapiutil.OpenApiRequest{
6548 Query: openapiutil.Query(query),
6549 }
6550 params := &openapiutil.Params{
6551 Action: dara.String("DescribeDomainRecordInfo"),
6552 Version: dara.String("2015-01-09"),
6553 Protocol: dara.String("HTTPS"),
6554 Pathname: dara.String("/"),
6555 Method: dara.String("POST"),
6556 AuthType: dara.String("AK"),
6557 Style: dara.String("RPC"),
6558 ReqBodyType: dara.String("formData"),
6559 BodyType: dara.String("json"),
6560 }
6561 _result = &DescribeDomainRecordInfoResponse{}
6562 _body, _err := client.CallApi(params, req, runtime)
6563 if _err != nil {
6564 return _result, _err
6565 }
6566 _err = dara.Convert(_body, &_result)
6567 return _result, _err
6568 }
6569
6570 // Summary:
6571 //
6572 // Queries the information about a Domain Name System (DNS) record by the ID of the DNS record.
6573 //
6574 // Description:
6575 //
6576 // ## Debugging
6577 //
6578 // [OpenAPI Explorer automatically calculates the signature value. For your convenience, we recommend that you call this operation in OpenAPI Explorer. OpenAPI Explorer dynamically generates the sample code of the operation for different SDKs.](https://api.aliyun.com/#product=Alidns\\&api=DescribeDomainRecordInfo\\&type=RPC\\&version=2015-01-09)
6579 //
6580 // @param request - DescribeDomainRecordInfoRequest
6581 //
6582 // @return DescribeDomainRecordInfoResponse
6583 func DescribeDomainRecordInfo(client *Client, request *DescribeDomainRecordInfoRequest) (_result *DescribeDomainRecordInfoResponse, _err error) {
6584 runtime := &dara.RuntimeOptions{}
6585 _result = &DescribeDomainRecordInfoResponse{}
6586 _body, _err := DescribeDomainRecordInfoWithOptions(client,request, runtime)
6587 if _err != nil {
6588 return _result, _err
6589 }
6590 _result = _body
6591 return _result, _err
6592 }
6593
6594 // Summary:
6595 //
6596 // Queries all Domain Name System (DNS) records of the specified primary domain names based on the specified parameters.
6597 //
6598 // Description:
6599 //
6600 // You can specify DomainName, PageNumber, and PageSize to query the DNS records of the specified domain names.
6601 //
6602 // - You can also specify RRKeyWord, TypeKeyWord, or ValueKeyWord to query the DNS records that contain the specified keyword.
6603 //
6604 // - By default, the DNS records are sorted in reverse chronological order based on the time when they were added.
6605 //
6606 // - You can specify GroupId to query the DNS records of the specified domain names based on the group ID. You can query the DNS records of all domain names and the domain names in the default group.
6607 //
6608 // @param request - DescribeDomainRecordsRequest
6609 //
6610 // @param runtime - runtime options for this request RuntimeOptions
6611 //
6612 // @return DescribeDomainRecordsResponse
6613 func DescribeDomainRecordsWithOptions(client *Client, request *DescribeDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainRecordsResponse, _err error) {
6614 if dara.BoolValue(client.EnableValidate) == true {
6615 _err = request.Validate()
6616 if _err != nil {
6617 return _result, _err
6618 }
6619 }
6620 query := map[string]interface{}{}
6621 if !dara.IsNil(request.Direction) {
6622 query["Direction"] = request.Direction
6623 }
6624
6625 if !dara.IsNil(request.DomainName) {
6626 query["DomainName"] = request.DomainName
6627 }
6628
6629 if !dara.IsNil(request.GroupId) {
6630 query["GroupId"] = request.GroupId
6631 }
6632
6633 if !dara.IsNil(request.KeyWord) {
6634 query["KeyWord"] = request.KeyWord
6635 }
6636
6637 if !dara.IsNil(request.Lang) {
6638 query["Lang"] = request.Lang
6639 }
6640
6641 if !dara.IsNil(request.Line) {
6642 query["Line"] = request.Line
6643 }
6644
6645 if !dara.IsNil(request.OrderBy) {
6646 query["OrderBy"] = request.OrderBy
6647 }
6648
6649 if !dara.IsNil(request.PageNumber) {
6650 query["PageNumber"] = request.PageNumber
6651 }
6652
6653 if !dara.IsNil(request.PageSize) {
6654 query["PageSize"] = request.PageSize
6655 }
6656
6657 if !dara.IsNil(request.RRKeyWord) {
6658 query["RRKeyWord"] = request.RRKeyWord
6659 }
6660
6661 if !dara.IsNil(request.SearchMode) {
6662 query["SearchMode"] = request.SearchMode
6663 }
6664
6665 if !dara.IsNil(request.Status) {
6666 query["Status"] = request.Status
6667 }
6668
6669 if !dara.IsNil(request.Type) {
6670 query["Type"] = request.Type
6671 }
6672
6673 if !dara.IsNil(request.TypeKeyWord) {
6674 query["TypeKeyWord"] = request.TypeKeyWord
6675 }
6676
6677 if !dara.IsNil(request.ValueKeyWord) {
6678 query["ValueKeyWord"] = request.ValueKeyWord
6679 }
6680
6681 req := &openapiutil.OpenApiRequest{
6682 Query: openapiutil.Query(query),
6683 }
6684 params := &openapiutil.Params{
6685 Action: dara.String("DescribeDomainRecords"),
6686 Version: dara.String("2015-01-09"),
6687 Protocol: dara.String("HTTPS"),
6688 Pathname: dara.String("/"),
6689 Method: dara.String("POST"),
6690 AuthType: dara.String("AK"),
6691 Style: dara.String("RPC"),
6692 ReqBodyType: dara.String("formData"),
6693 BodyType: dara.String("json"),
6694 }
6695 _result = &DescribeDomainRecordsResponse{}
6696 _body, _err := client.CallApi(params, req, runtime)
6697 if _err != nil {
6698 return _result, _err
6699 }
6700 _err = dara.Convert(_body, &_result)
6701 return _result, _err
6702 }
6703
6704 // Summary:
6705 //
6706 // Queries all Domain Name System (DNS) records of the specified primary domain names based on the specified parameters.
6707 //
6708 // Description:
6709 //
6710 // You can specify DomainName, PageNumber, and PageSize to query the DNS records of the specified domain names.
6711 //
6712 // - You can also specify RRKeyWord, TypeKeyWord, or ValueKeyWord to query the DNS records that contain the specified keyword.
6713 //
6714 // - By default, the DNS records are sorted in reverse chronological order based on the time when they were added.
6715 //
6716 // - You can specify GroupId to query the DNS records of the specified domain names based on the group ID. You can query the DNS records of all domain names and the domain names in the default group.
6717 //
6718 // @param request - DescribeDomainRecordsRequest
6719 //
6720 // @return DescribeDomainRecordsResponse
6721 func DescribeDomainRecords(client *Client, request *DescribeDomainRecordsRequest) (_result *DescribeDomainRecordsResponse, _err error) {
6722 runtime := &dara.RuntimeOptions{}
6723 _result = &DescribeDomainRecordsResponse{}
6724 _body, _err := DescribeDomainRecordsWithOptions(client,request, runtime)
6725 if _err != nil {
6726 return _result, _err
6727 }
6728 _result = _body
6729 return _result, _err
6730 }
6731
6732 // Summary:
6733 //
6734 // Queries the resolution requests of all paid domain names within your account.
6735 //
6736 // @param request - DescribeDomainResolveStatisticsSummaryRequest
6737 //
6738 // @param runtime - runtime options for this request RuntimeOptions
6739 //
6740 // @return DescribeDomainResolveStatisticsSummaryResponse
6741 func DescribeDomainResolveStatisticsSummaryWithOptions(client *Client, request *DescribeDomainResolveStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainResolveStatisticsSummaryResponse, _err error) {
6742 if dara.BoolValue(client.EnableValidate) == true {
6743 _err = request.Validate()
6744 if _err != nil {
6745 return _result, _err
6746 }
6747 }
6748 query := map[string]interface{}{}
6749 if !dara.IsNil(request.Direction) {
6750 query["Direction"] = request.Direction
6751 }
6752
6753 if !dara.IsNil(request.EndDate) {
6754 query["EndDate"] = request.EndDate
6755 }
6756
6757 if !dara.IsNil(request.Keyword) {
6758 query["Keyword"] = request.Keyword
6759 }
6760
6761 if !dara.IsNil(request.Lang) {
6762 query["Lang"] = request.Lang
6763 }
6764
6765 if !dara.IsNil(request.PageNumber) {
6766 query["PageNumber"] = request.PageNumber
6767 }
6768
6769 if !dara.IsNil(request.PageSize) {
6770 query["PageSize"] = request.PageSize
6771 }
6772
6773 if !dara.IsNil(request.SearchMode) {
6774 query["SearchMode"] = request.SearchMode
6775 }
6776
6777 if !dara.IsNil(request.StartDate) {
6778 query["StartDate"] = request.StartDate
6779 }
6780
6781 if !dara.IsNil(request.Threshold) {
6782 query["Threshold"] = request.Threshold
6783 }
6784
6785 req := &openapiutil.OpenApiRequest{
6786 Query: openapiutil.Query(query),
6787 }
6788 params := &openapiutil.Params{
6789 Action: dara.String("DescribeDomainResolveStatisticsSummary"),
6790 Version: dara.String("2015-01-09"),
6791 Protocol: dara.String("HTTPS"),
6792 Pathname: dara.String("/"),
6793 Method: dara.String("POST"),
6794 AuthType: dara.String("AK"),
6795 Style: dara.String("RPC"),
6796 ReqBodyType: dara.String("formData"),
6797 BodyType: dara.String("json"),
6798 }
6799 _result = &DescribeDomainResolveStatisticsSummaryResponse{}
6800 _body, _err := client.CallApi(params, req, runtime)
6801 if _err != nil {
6802 return _result, _err
6803 }
6804 _err = dara.Convert(_body, &_result)
6805 return _result, _err
6806 }
6807
6808 // Summary:
6809 //
6810 // Queries the resolution requests of all paid domain names within your account.
6811 //
6812 // @param request - DescribeDomainResolveStatisticsSummaryRequest
6813 //
6814 // @return DescribeDomainResolveStatisticsSummaryResponse
6815 func DescribeDomainResolveStatisticsSummary(client *Client, request *DescribeDomainResolveStatisticsSummaryRequest) (_result *DescribeDomainResolveStatisticsSummaryResponse, _err error) {
6816 runtime := &dara.RuntimeOptions{}
6817 _result = &DescribeDomainResolveStatisticsSummaryResponse{}
6818 _body, _err := DescribeDomainResolveStatisticsSummaryWithOptions(client,request, runtime)
6819 if _err != nil {
6820 return _result, _err
6821 }
6822 _result = _body
6823 return _result, _err
6824 }
6825
6826 // Summary:
6827 //
6828 // Queries the real-time statistics on the Domain Name System (DNS) requests for a primary domain name.
6829 //
6830 // Description:
6831 //
6832 // Real-time data is collected per hour.
6833 //
6834 // @param request - DescribeDomainStatisticsRequest
6835 //
6836 // @param runtime - runtime options for this request RuntimeOptions
6837 //
6838 // @return DescribeDomainStatisticsResponse
6839 func DescribeDomainStatisticsWithOptions(client *Client, request *DescribeDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainStatisticsResponse, _err error) {
6840 if dara.BoolValue(client.EnableValidate) == true {
6841 _err = request.Validate()
6842 if _err != nil {
6843 return _result, _err
6844 }
6845 }
6846 query := map[string]interface{}{}
6847 if !dara.IsNil(request.DomainName) {
6848 query["DomainName"] = request.DomainName
6849 }
6850
6851 if !dara.IsNil(request.DomainType) {
6852 query["DomainType"] = request.DomainType
6853 }
6854
6855 if !dara.IsNil(request.EndDate) {
6856 query["EndDate"] = request.EndDate
6857 }
6858
6859 if !dara.IsNil(request.Lang) {
6860 query["Lang"] = request.Lang
6861 }
6862
6863 if !dara.IsNil(request.StartDate) {
6864 query["StartDate"] = request.StartDate
6865 }
6866
6867 req := &openapiutil.OpenApiRequest{
6868 Query: openapiutil.Query(query),
6869 }
6870 params := &openapiutil.Params{
6871 Action: dara.String("DescribeDomainStatistics"),
6872 Version: dara.String("2015-01-09"),
6873 Protocol: dara.String("HTTPS"),
6874 Pathname: dara.String("/"),
6875 Method: dara.String("POST"),
6876 AuthType: dara.String("AK"),
6877 Style: dara.String("RPC"),
6878 ReqBodyType: dara.String("formData"),
6879 BodyType: dara.String("json"),
6880 }
6881 _result = &DescribeDomainStatisticsResponse{}
6882 _body, _err := client.CallApi(params, req, runtime)
6883 if _err != nil {
6884 return _result, _err
6885 }
6886 _err = dara.Convert(_body, &_result)
6887 return _result, _err
6888 }
6889
6890 // Summary:
6891 //
6892 // Queries the real-time statistics on the Domain Name System (DNS) requests for a primary domain name.
6893 //
6894 // Description:
6895 //
6896 // Real-time data is collected per hour.
6897 //
6898 // @param request - DescribeDomainStatisticsRequest
6899 //
6900 // @return DescribeDomainStatisticsResponse
6901 func DescribeDomainStatistics(client *Client, request *DescribeDomainStatisticsRequest) (_result *DescribeDomainStatisticsResponse, _err error) {
6902 runtime := &dara.RuntimeOptions{}
6903 _result = &DescribeDomainStatisticsResponse{}
6904 _body, _err := DescribeDomainStatisticsWithOptions(client,request, runtime)
6905 if _err != nil {
6906 return _result, _err
6907 }
6908 _result = _body
6909 return _result, _err
6910 }
6911
6912 // Summary:
6913 //
6914 // Calls the DescribeDomainStatisticsSummary operation to obtain the query volume of all paid domain names under your account.
6915 //
6916 // @param request - DescribeDomainStatisticsSummaryRequest
6917 //
6918 // @param runtime - runtime options for this request RuntimeOptions
6919 //
6920 // @return DescribeDomainStatisticsSummaryResponse
6921 func DescribeDomainStatisticsSummaryWithOptions(client *Client, request *DescribeDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainStatisticsSummaryResponse, _err error) {
6922 if dara.BoolValue(client.EnableValidate) == true {
6923 _err = request.Validate()
6924 if _err != nil {
6925 return _result, _err
6926 }
6927 }
6928 query := map[string]interface{}{}
6929 if !dara.IsNil(request.EndDate) {
6930 query["EndDate"] = request.EndDate
6931 }
6932
6933 if !dara.IsNil(request.Keyword) {
6934 query["Keyword"] = request.Keyword
6935 }
6936
6937 if !dara.IsNil(request.Lang) {
6938 query["Lang"] = request.Lang
6939 }
6940
6941 if !dara.IsNil(request.PageNumber) {
6942 query["PageNumber"] = request.PageNumber
6943 }
6944
6945 if !dara.IsNil(request.PageSize) {
6946 query["PageSize"] = request.PageSize
6947 }
6948
6949 if !dara.IsNil(request.SearchMode) {
6950 query["SearchMode"] = request.SearchMode
6951 }
6952
6953 if !dara.IsNil(request.StartDate) {
6954 query["StartDate"] = request.StartDate
6955 }
6956
6957 if !dara.IsNil(request.Threshold) {
6958 query["Threshold"] = request.Threshold
6959 }
6960
6961 req := &openapiutil.OpenApiRequest{
6962 Query: openapiutil.Query(query),
6963 }
6964 params := &openapiutil.Params{
6965 Action: dara.String("DescribeDomainStatisticsSummary"),
6966 Version: dara.String("2015-01-09"),
6967 Protocol: dara.String("HTTPS"),
6968 Pathname: dara.String("/"),
6969 Method: dara.String("POST"),
6970 AuthType: dara.String("AK"),
6971 Style: dara.String("RPC"),
6972 ReqBodyType: dara.String("formData"),
6973 BodyType: dara.String("json"),
6974 }
6975 _result = &DescribeDomainStatisticsSummaryResponse{}
6976 _body, _err := client.CallApi(params, req, runtime)
6977 if _err != nil {
6978 return _result, _err
6979 }
6980 _err = dara.Convert(_body, &_result)
6981 return _result, _err
6982 }
6983
6984 // Summary:
6985 //
6986 // Calls the DescribeDomainStatisticsSummary operation to obtain the query volume of all paid domain names under your account.
6987 //
6988 // @param request - DescribeDomainStatisticsSummaryRequest
6989 //
6990 // @return DescribeDomainStatisticsSummaryResponse
6991 func DescribeDomainStatisticsSummary(client *Client, request *DescribeDomainStatisticsSummaryRequest) (_result *DescribeDomainStatisticsSummaryResponse, _err error) {
6992 runtime := &dara.RuntimeOptions{}
6993 _result = &DescribeDomainStatisticsSummaryResponse{}
6994 _body, _err := DescribeDomainStatisticsSummaryWithOptions(client,request, runtime)
6995 if _err != nil {
6996 return _result, _err
6997 }
6998 _result = _body
6999 return _result, _err
7000 }
7001
7002 // Summary:
7003 //
7004 // Calls the DescribeDomains operation to query domain names of a user based on input parameters.
7005 //
7006 // Description:
7007 //
7008 // You can specify the PageNumber and PageSize parameters to query domain names.
7009 //
7010 // - You can specify the KeyWord parameter to query domain names that contain the specified keyword.
7011 //
7012 // - By default, the domain names in a list are sorted in descending order of the time they were added.
7013 //
7014 // - You can specify the GroupId parameter. If you do not specify this parameter, all domain names are queried by default.
7015 //
7016 // @param request - DescribeDomainsRequest
7017 //
7018 // @param runtime - runtime options for this request RuntimeOptions
7019 //
7020 // @return DescribeDomainsResponse
7021 func DescribeDomainsWithOptions(client *Client, request *DescribeDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainsResponse, _err error) {
7022 if dara.BoolValue(client.EnableValidate) == true {
7023 _err = request.Validate()
7024 if _err != nil {
7025 return _result, _err
7026 }
7027 }
7028 query := map[string]interface{}{}
7029 if !dara.IsNil(request.GroupId) {
7030 query["GroupId"] = request.GroupId
7031 }
7032
7033 if !dara.IsNil(request.KeyWord) {
7034 query["KeyWord"] = request.KeyWord
7035 }
7036
7037 if !dara.IsNil(request.Lang) {
7038 query["Lang"] = request.Lang
7039 }
7040
7041 if !dara.IsNil(request.PageNumber) {
7042 query["PageNumber"] = request.PageNumber
7043 }
7044
7045 if !dara.IsNil(request.PageSize) {
7046 query["PageSize"] = request.PageSize
7047 }
7048
7049 if !dara.IsNil(request.ResourceGroupId) {
7050 query["ResourceGroupId"] = request.ResourceGroupId
7051 }
7052
7053 if !dara.IsNil(request.SearchMode) {
7054 query["SearchMode"] = request.SearchMode
7055 }
7056
7057 if !dara.IsNil(request.Starmark) {
7058 query["Starmark"] = request.Starmark
7059 }
7060
7061 req := &openapiutil.OpenApiRequest{
7062 Query: openapiutil.Query(query),
7063 }
7064 params := &openapiutil.Params{
7065 Action: dara.String("DescribeDomains"),
7066 Version: dara.String("2015-01-09"),
7067 Protocol: dara.String("HTTPS"),
7068 Pathname: dara.String("/"),
7069 Method: dara.String("POST"),
7070 AuthType: dara.String("AK"),
7071 Style: dara.String("RPC"),
7072 ReqBodyType: dara.String("formData"),
7073 BodyType: dara.String("json"),
7074 }
7075 _result = &DescribeDomainsResponse{}
7076 _body, _err := client.CallApi(params, req, runtime)
7077 if _err != nil {
7078 return _result, _err
7079 }
7080 _err = dara.Convert(_body, &_result)
7081 return _result, _err
7082 }
7083
7084 // Summary:
7085 //
7086 // Calls the DescribeDomains operation to query domain names of a user based on input parameters.
7087 //
7088 // Description:
7089 //
7090 // You can specify the PageNumber and PageSize parameters to query domain names.
7091 //
7092 // - You can specify the KeyWord parameter to query domain names that contain the specified keyword.
7093 //
7094 // - By default, the domain names in a list are sorted in descending order of the time they were added.
7095 //
7096 // - You can specify the GroupId parameter. If you do not specify this parameter, all domain names are queried by default.
7097 //
7098 // @param request - DescribeDomainsRequest
7099 //
7100 // @return DescribeDomainsResponse
7101 func DescribeDomains(client *Client, request *DescribeDomainsRequest) (_result *DescribeDomainsResponse, _err error) {
7102 runtime := &dara.RuntimeOptions{}
7103 _result = &DescribeDomainsResponse{}
7104 _body, _err := DescribeDomainsWithOptions(client,request, runtime)
7105 if _err != nil {
7106 return _result, _err
7107 }
7108 _result = _body
7109 return _result, _err
7110 }
7111
7112 // Summary:
7113 //
7114 // You can call this operation to query the access policies of a Global Traffic Manager (GTM) instance.
7115 //
7116 // @param request - DescribeGtmAccessStrategiesRequest
7117 //
7118 // @param runtime - runtime options for this request RuntimeOptions
7119 //
7120 // @return DescribeGtmAccessStrategiesResponse
7121 func DescribeGtmAccessStrategiesWithOptions(client *Client, request *DescribeGtmAccessStrategiesRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategiesResponse, _err error) {
7122 if dara.BoolValue(client.EnableValidate) == true {
7123 _err = request.Validate()
7124 if _err != nil {
7125 return _result, _err
7126 }
7127 }
7128 query := map[string]interface{}{}
7129 if !dara.IsNil(request.InstanceId) {
7130 query["InstanceId"] = request.InstanceId
7131 }
7132
7133 if !dara.IsNil(request.Lang) {
7134 query["Lang"] = request.Lang
7135 }
7136
7137 if !dara.IsNil(request.PageNumber) {
7138 query["PageNumber"] = request.PageNumber
7139 }
7140
7141 if !dara.IsNil(request.PageSize) {
7142 query["PageSize"] = request.PageSize
7143 }
7144
7145 req := &openapiutil.OpenApiRequest{
7146 Query: openapiutil.Query(query),
7147 }
7148 params := &openapiutil.Params{
7149 Action: dara.String("DescribeGtmAccessStrategies"),
7150 Version: dara.String("2015-01-09"),
7151 Protocol: dara.String("HTTPS"),
7152 Pathname: dara.String("/"),
7153 Method: dara.String("POST"),
7154 AuthType: dara.String("AK"),
7155 Style: dara.String("RPC"),
7156 ReqBodyType: dara.String("formData"),
7157 BodyType: dara.String("json"),
7158 }
7159 _result = &DescribeGtmAccessStrategiesResponse{}
7160 _body, _err := client.CallApi(params, req, runtime)
7161 if _err != nil {
7162 return _result, _err
7163 }
7164 _err = dara.Convert(_body, &_result)
7165 return _result, _err
7166 }
7167
7168 // Summary:
7169 //
7170 // You can call this operation to query the access policies of a Global Traffic Manager (GTM) instance.
7171 //
7172 // @param request - DescribeGtmAccessStrategiesRequest
7173 //
7174 // @return DescribeGtmAccessStrategiesResponse
7175 func DescribeGtmAccessStrategies(client *Client, request *DescribeGtmAccessStrategiesRequest) (_result *DescribeGtmAccessStrategiesResponse, _err error) {
7176 runtime := &dara.RuntimeOptions{}
7177 _result = &DescribeGtmAccessStrategiesResponse{}
7178 _body, _err := DescribeGtmAccessStrategiesWithOptions(client,request, runtime)
7179 if _err != nil {
7180 return _result, _err
7181 }
7182 _result = _body
7183 return _result, _err
7184 }
7185
7186 // Summary:
7187 //
7188 // You can call this operation to query the details about an access policy of a Global Traffic Manager (GTM) instance based on the policy ID.
7189 //
7190 // @param request - DescribeGtmAccessStrategyRequest
7191 //
7192 // @param runtime - runtime options for this request RuntimeOptions
7193 //
7194 // @return DescribeGtmAccessStrategyResponse
7195 func DescribeGtmAccessStrategyWithOptions(client *Client, request *DescribeGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategyResponse, _err error) {
7196 if dara.BoolValue(client.EnableValidate) == true {
7197 _err = request.Validate()
7198 if _err != nil {
7199 return _result, _err
7200 }
7201 }
7202 query := map[string]interface{}{}
7203 if !dara.IsNil(request.Lang) {
7204 query["Lang"] = request.Lang
7205 }
7206
7207 if !dara.IsNil(request.StrategyId) {
7208 query["StrategyId"] = request.StrategyId
7209 }
7210
7211 req := &openapiutil.OpenApiRequest{
7212 Query: openapiutil.Query(query),
7213 }
7214 params := &openapiutil.Params{
7215 Action: dara.String("DescribeGtmAccessStrategy"),
7216 Version: dara.String("2015-01-09"),
7217 Protocol: dara.String("HTTPS"),
7218 Pathname: dara.String("/"),
7219 Method: dara.String("POST"),
7220 AuthType: dara.String("AK"),
7221 Style: dara.String("RPC"),
7222 ReqBodyType: dara.String("formData"),
7223 BodyType: dara.String("json"),
7224 }
7225 _result = &DescribeGtmAccessStrategyResponse{}
7226 _body, _err := client.CallApi(params, req, runtime)
7227 if _err != nil {
7228 return _result, _err
7229 }
7230 _err = dara.Convert(_body, &_result)
7231 return _result, _err
7232 }
7233
7234 // Summary:
7235 //
7236 // You can call this operation to query the details about an access policy of a Global Traffic Manager (GTM) instance based on the policy ID.
7237 //
7238 // @param request - DescribeGtmAccessStrategyRequest
7239 //
7240 // @return DescribeGtmAccessStrategyResponse
7241 func DescribeGtmAccessStrategy(client *Client, request *DescribeGtmAccessStrategyRequest) (_result *DescribeGtmAccessStrategyResponse, _err error) {
7242 runtime := &dara.RuntimeOptions{}
7243 _result = &DescribeGtmAccessStrategyResponse{}
7244 _body, _err := DescribeGtmAccessStrategyWithOptions(client,request, runtime)
7245 if _err != nil {
7246 return _result, _err
7247 }
7248 _result = _body
7249 return _result, _err
7250 }
7251
7252 // Summary:
7253 //
7254 // Queries the configuration items that can be set for an access policy.
7255 //
7256 // @param request - DescribeGtmAccessStrategyAvailableConfigRequest
7257 //
7258 // @param runtime - runtime options for this request RuntimeOptions
7259 //
7260 // @return DescribeGtmAccessStrategyAvailableConfigResponse
7261 func DescribeGtmAccessStrategyAvailableConfigWithOptions(client *Client, request *DescribeGtmAccessStrategyAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategyAvailableConfigResponse, _err error) {
7262 if dara.BoolValue(client.EnableValidate) == true {
7263 _err = request.Validate()
7264 if _err != nil {
7265 return _result, _err
7266 }
7267 }
7268 query := map[string]interface{}{}
7269 if !dara.IsNil(request.InstanceId) {
7270 query["InstanceId"] = request.InstanceId
7271 }
7272
7273 if !dara.IsNil(request.Lang) {
7274 query["Lang"] = request.Lang
7275 }
7276
7277 req := &openapiutil.OpenApiRequest{
7278 Query: openapiutil.Query(query),
7279 }
7280 params := &openapiutil.Params{
7281 Action: dara.String("DescribeGtmAccessStrategyAvailableConfig"),
7282 Version: dara.String("2015-01-09"),
7283 Protocol: dara.String("HTTPS"),
7284 Pathname: dara.String("/"),
7285 Method: dara.String("POST"),
7286 AuthType: dara.String("AK"),
7287 Style: dara.String("RPC"),
7288 ReqBodyType: dara.String("formData"),
7289 BodyType: dara.String("json"),
7290 }
7291 _result = &DescribeGtmAccessStrategyAvailableConfigResponse{}
7292 _body, _err := client.CallApi(params, req, runtime)
7293 if _err != nil {
7294 return _result, _err
7295 }
7296 _err = dara.Convert(_body, &_result)
7297 return _result, _err
7298 }
7299
7300 // Summary:
7301 //
7302 // Queries the configuration items that can be set for an access policy.
7303 //
7304 // @param request - DescribeGtmAccessStrategyAvailableConfigRequest
7305 //
7306 // @return DescribeGtmAccessStrategyAvailableConfigResponse
7307 func DescribeGtmAccessStrategyAvailableConfig(client *Client, request *DescribeGtmAccessStrategyAvailableConfigRequest) (_result *DescribeGtmAccessStrategyAvailableConfigResponse, _err error) {
7308 runtime := &dara.RuntimeOptions{}
7309 _result = &DescribeGtmAccessStrategyAvailableConfigResponse{}
7310 _body, _err := DescribeGtmAccessStrategyAvailableConfigWithOptions(client,request, runtime)
7311 if _err != nil {
7312 return _result, _err
7313 }
7314 _result = _body
7315 return _result, _err
7316 }
7317
7318 // @param request - DescribeGtmAvailableAlertGroupRequest
7319 //
7320 // @param runtime - runtime options for this request RuntimeOptions
7321 //
7322 // @return DescribeGtmAvailableAlertGroupResponse
7323 func DescribeGtmAvailableAlertGroupWithOptions(client *Client, request *DescribeGtmAvailableAlertGroupRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAvailableAlertGroupResponse, _err error) {
7324 if dara.BoolValue(client.EnableValidate) == true {
7325 _err = request.Validate()
7326 if _err != nil {
7327 return _result, _err
7328 }
7329 }
7330 query := map[string]interface{}{}
7331 if !dara.IsNil(request.Lang) {
7332 query["Lang"] = request.Lang
7333 }
7334
7335 req := &openapiutil.OpenApiRequest{
7336 Query: openapiutil.Query(query),
7337 }
7338 params := &openapiutil.Params{
7339 Action: dara.String("DescribeGtmAvailableAlertGroup"),
7340 Version: dara.String("2015-01-09"),
7341 Protocol: dara.String("HTTPS"),
7342 Pathname: dara.String("/"),
7343 Method: dara.String("POST"),
7344 AuthType: dara.String("AK"),
7345 Style: dara.String("RPC"),
7346 ReqBodyType: dara.String("formData"),
7347 BodyType: dara.String("json"),
7348 }
7349 _result = &DescribeGtmAvailableAlertGroupResponse{}
7350 _body, _err := client.CallApi(params, req, runtime)
7351 if _err != nil {
7352 return _result, _err
7353 }
7354 _err = dara.Convert(_body, &_result)
7355 return _result, _err
7356 }
7357
7358 // @param request - DescribeGtmAvailableAlertGroupRequest
7359 //
7360 // @return DescribeGtmAvailableAlertGroupResponse
7361 func DescribeGtmAvailableAlertGroup(client *Client, request *DescribeGtmAvailableAlertGroupRequest) (_result *DescribeGtmAvailableAlertGroupResponse, _err error) {
7362 runtime := &dara.RuntimeOptions{}
7363 _result = &DescribeGtmAvailableAlertGroupResponse{}
7364 _body, _err := DescribeGtmAvailableAlertGroupWithOptions(client,request, runtime)
7365 if _err != nil {
7366 return _result, _err
7367 }
7368 _result = _body
7369 return _result, _err
7370 }
7371
7372 // Summary:
7373 //
7374 // Queries the details about a Global Traffic Manager (GTM) instance.
7375 //
7376 // @param request - DescribeGtmInstanceRequest
7377 //
7378 // @param runtime - runtime options for this request RuntimeOptions
7379 //
7380 // @return DescribeGtmInstanceResponse
7381 func DescribeGtmInstanceWithOptions(client *Client, request *DescribeGtmInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceResponse, _err error) {
7382 if dara.BoolValue(client.EnableValidate) == true {
7383 _err = request.Validate()
7384 if _err != nil {
7385 return _result, _err
7386 }
7387 }
7388 query := map[string]interface{}{}
7389 if !dara.IsNil(request.InstanceId) {
7390 query["InstanceId"] = request.InstanceId
7391 }
7392
7393 if !dara.IsNil(request.Lang) {
7394 query["Lang"] = request.Lang
7395 }
7396
7397 if !dara.IsNil(request.NeedDetailAttributes) {
7398 query["NeedDetailAttributes"] = request.NeedDetailAttributes
7399 }
7400
7401 req := &openapiutil.OpenApiRequest{
7402 Query: openapiutil.Query(query),
7403 }
7404 params := &openapiutil.Params{
7405 Action: dara.String("DescribeGtmInstance"),
7406 Version: dara.String("2015-01-09"),
7407 Protocol: dara.String("HTTPS"),
7408 Pathname: dara.String("/"),
7409 Method: dara.String("POST"),
7410 AuthType: dara.String("AK"),
7411 Style: dara.String("RPC"),
7412 ReqBodyType: dara.String("formData"),
7413 BodyType: dara.String("json"),
7414 }
7415 _result = &DescribeGtmInstanceResponse{}
7416 _body, _err := client.CallApi(params, req, runtime)
7417 if _err != nil {
7418 return _result, _err
7419 }
7420 _err = dara.Convert(_body, &_result)
7421 return _result, _err
7422 }
7423
7424 // Summary:
7425 //
7426 // Queries the details about a Global Traffic Manager (GTM) instance.
7427 //
7428 // @param request - DescribeGtmInstanceRequest
7429 //
7430 // @return DescribeGtmInstanceResponse
7431 func DescribeGtmInstance(client *Client, request *DescribeGtmInstanceRequest) (_result *DescribeGtmInstanceResponse, _err error) {
7432 runtime := &dara.RuntimeOptions{}
7433 _result = &DescribeGtmInstanceResponse{}
7434 _body, _err := DescribeGtmInstanceWithOptions(client,request, runtime)
7435 if _err != nil {
7436 return _result, _err
7437 }
7438 _result = _body
7439 return _result, _err
7440 }
7441
7442 // Summary:
7443 //
7444 // You can call this operation to query the details about an address pool of a Global Traffic Manager (GTM) instance.
7445 //
7446 // @param request - DescribeGtmInstanceAddressPoolRequest
7447 //
7448 // @param runtime - runtime options for this request RuntimeOptions
7449 //
7450 // @return DescribeGtmInstanceAddressPoolResponse
7451 func DescribeGtmInstanceAddressPoolWithOptions(client *Client, request *DescribeGtmInstanceAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceAddressPoolResponse, _err error) {
7452 if dara.BoolValue(client.EnableValidate) == true {
7453 _err = request.Validate()
7454 if _err != nil {
7455 return _result, _err
7456 }
7457 }
7458 query := map[string]interface{}{}
7459 if !dara.IsNil(request.AddrPoolId) {
7460 query["AddrPoolId"] = request.AddrPoolId
7461 }
7462
7463 if !dara.IsNil(request.Lang) {
7464 query["Lang"] = request.Lang
7465 }
7466
7467 req := &openapiutil.OpenApiRequest{
7468 Query: openapiutil.Query(query),
7469 }
7470 params := &openapiutil.Params{
7471 Action: dara.String("DescribeGtmInstanceAddressPool"),
7472 Version: dara.String("2015-01-09"),
7473 Protocol: dara.String("HTTPS"),
7474 Pathname: dara.String("/"),
7475 Method: dara.String("POST"),
7476 AuthType: dara.String("AK"),
7477 Style: dara.String("RPC"),
7478 ReqBodyType: dara.String("formData"),
7479 BodyType: dara.String("json"),
7480 }
7481 _result = &DescribeGtmInstanceAddressPoolResponse{}
7482 _body, _err := client.CallApi(params, req, runtime)
7483 if _err != nil {
7484 return _result, _err
7485 }
7486 _err = dara.Convert(_body, &_result)
7487 return _result, _err
7488 }
7489
7490 // Summary:
7491 //
7492 // You can call this operation to query the details about an address pool of a Global Traffic Manager (GTM) instance.
7493 //
7494 // @param request - DescribeGtmInstanceAddressPoolRequest
7495 //
7496 // @return DescribeGtmInstanceAddressPoolResponse
7497 func DescribeGtmInstanceAddressPool(client *Client, request *DescribeGtmInstanceAddressPoolRequest) (_result *DescribeGtmInstanceAddressPoolResponse, _err error) {
7498 runtime := &dara.RuntimeOptions{}
7499 _result = &DescribeGtmInstanceAddressPoolResponse{}
7500 _body, _err := DescribeGtmInstanceAddressPoolWithOptions(client,request, runtime)
7501 if _err != nil {
7502 return _result, _err
7503 }
7504 _result = _body
7505 return _result, _err
7506 }
7507
7508 // Summary:
7509 //
7510 // You can call this operation to query the address pools of a Global Traffic Manager (GTM) instance.
7511 //
7512 // @param request - DescribeGtmInstanceAddressPoolsRequest
7513 //
7514 // @param runtime - runtime options for this request RuntimeOptions
7515 //
7516 // @return DescribeGtmInstanceAddressPoolsResponse
7517 func DescribeGtmInstanceAddressPoolsWithOptions(client *Client, request *DescribeGtmInstanceAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceAddressPoolsResponse, _err error) {
7518 if dara.BoolValue(client.EnableValidate) == true {
7519 _err = request.Validate()
7520 if _err != nil {
7521 return _result, _err
7522 }
7523 }
7524 query := map[string]interface{}{}
7525 if !dara.IsNil(request.InstanceId) {
7526 query["InstanceId"] = request.InstanceId
7527 }
7528
7529 if !dara.IsNil(request.Lang) {
7530 query["Lang"] = request.Lang
7531 }
7532
7533 if !dara.IsNil(request.PageNumber) {
7534 query["PageNumber"] = request.PageNumber
7535 }
7536
7537 if !dara.IsNil(request.PageSize) {
7538 query["PageSize"] = request.PageSize
7539 }
7540
7541 req := &openapiutil.OpenApiRequest{
7542 Query: openapiutil.Query(query),
7543 }
7544 params := &openapiutil.Params{
7545 Action: dara.String("DescribeGtmInstanceAddressPools"),
7546 Version: dara.String("2015-01-09"),
7547 Protocol: dara.String("HTTPS"),
7548 Pathname: dara.String("/"),
7549 Method: dara.String("POST"),
7550 AuthType: dara.String("AK"),
7551 Style: dara.String("RPC"),
7552 ReqBodyType: dara.String("formData"),
7553 BodyType: dara.String("json"),
7554 }
7555 _result = &DescribeGtmInstanceAddressPoolsResponse{}
7556 _body, _err := client.CallApi(params, req, runtime)
7557 if _err != nil {
7558 return _result, _err
7559 }
7560 _err = dara.Convert(_body, &_result)
7561 return _result, _err
7562 }
7563
7564 // Summary:
7565 //
7566 // You can call this operation to query the address pools of a Global Traffic Manager (GTM) instance.
7567 //
7568 // @param request - DescribeGtmInstanceAddressPoolsRequest
7569 //
7570 // @return DescribeGtmInstanceAddressPoolsResponse
7571 func DescribeGtmInstanceAddressPools(client *Client, request *DescribeGtmInstanceAddressPoolsRequest) (_result *DescribeGtmInstanceAddressPoolsResponse, _err error) {
7572 runtime := &dara.RuntimeOptions{}
7573 _result = &DescribeGtmInstanceAddressPoolsResponse{}
7574 _body, _err := DescribeGtmInstanceAddressPoolsWithOptions(client,request, runtime)
7575 if _err != nil {
7576 return _result, _err
7577 }
7578 _result = _body
7579 return _result, _err
7580 }
7581
7582 // Summary:
7583 //
7584 // Queries the status of a Global Traffic Manager (GTM) instance.
7585 //
7586 // @param request - DescribeGtmInstanceStatusRequest
7587 //
7588 // @param runtime - runtime options for this request RuntimeOptions
7589 //
7590 // @return DescribeGtmInstanceStatusResponse
7591 func DescribeGtmInstanceStatusWithOptions(client *Client, request *DescribeGtmInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceStatusResponse, _err error) {
7592 if dara.BoolValue(client.EnableValidate) == true {
7593 _err = request.Validate()
7594 if _err != nil {
7595 return _result, _err
7596 }
7597 }
7598 query := map[string]interface{}{}
7599 if !dara.IsNil(request.InstanceId) {
7600 query["InstanceId"] = request.InstanceId
7601 }
7602
7603 if !dara.IsNil(request.Lang) {
7604 query["Lang"] = request.Lang
7605 }
7606
7607 req := &openapiutil.OpenApiRequest{
7608 Query: openapiutil.Query(query),
7609 }
7610 params := &openapiutil.Params{
7611 Action: dara.String("DescribeGtmInstanceStatus"),
7612 Version: dara.String("2015-01-09"),
7613 Protocol: dara.String("HTTPS"),
7614 Pathname: dara.String("/"),
7615 Method: dara.String("POST"),
7616 AuthType: dara.String("AK"),
7617 Style: dara.String("RPC"),
7618 ReqBodyType: dara.String("formData"),
7619 BodyType: dara.String("json"),
7620 }
7621 _result = &DescribeGtmInstanceStatusResponse{}
7622 _body, _err := client.CallApi(params, req, runtime)
7623 if _err != nil {
7624 return _result, _err
7625 }
7626 _err = dara.Convert(_body, &_result)
7627 return _result, _err
7628 }
7629
7630 // Summary:
7631 //
7632 // Queries the status of a Global Traffic Manager (GTM) instance.
7633 //
7634 // @param request - DescribeGtmInstanceStatusRequest
7635 //
7636 // @return DescribeGtmInstanceStatusResponse
7637 func DescribeGtmInstanceStatus(client *Client, request *DescribeGtmInstanceStatusRequest) (_result *DescribeGtmInstanceStatusResponse, _err error) {
7638 runtime := &dara.RuntimeOptions{}
7639 _result = &DescribeGtmInstanceStatusResponse{}
7640 _body, _err := DescribeGtmInstanceStatusWithOptions(client,request, runtime)
7641 if _err != nil {
7642 return _result, _err
7643 }
7644 _result = _body
7645 return _result, _err
7646 }
7647
7648 // @param request - DescribeGtmInstanceSystemCnameRequest
7649 //
7650 // @param runtime - runtime options for this request RuntimeOptions
7651 //
7652 // @return DescribeGtmInstanceSystemCnameResponse
7653 func DescribeGtmInstanceSystemCnameWithOptions(client *Client, request *DescribeGtmInstanceSystemCnameRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceSystemCnameResponse, _err error) {
7654 if dara.BoolValue(client.EnableValidate) == true {
7655 _err = request.Validate()
7656 if _err != nil {
7657 return _result, _err
7658 }
7659 }
7660 query := map[string]interface{}{}
7661 if !dara.IsNil(request.InstanceId) {
7662 query["InstanceId"] = request.InstanceId
7663 }
7664
7665 if !dara.IsNil(request.Lang) {
7666 query["Lang"] = request.Lang
7667 }
7668
7669 req := &openapiutil.OpenApiRequest{
7670 Query: openapiutil.Query(query),
7671 }
7672 params := &openapiutil.Params{
7673 Action: dara.String("DescribeGtmInstanceSystemCname"),
7674 Version: dara.String("2015-01-09"),
7675 Protocol: dara.String("HTTPS"),
7676 Pathname: dara.String("/"),
7677 Method: dara.String("POST"),
7678 AuthType: dara.String("AK"),
7679 Style: dara.String("RPC"),
7680 ReqBodyType: dara.String("formData"),
7681 BodyType: dara.String("json"),
7682 }
7683 _result = &DescribeGtmInstanceSystemCnameResponse{}
7684 _body, _err := client.CallApi(params, req, runtime)
7685 if _err != nil {
7686 return _result, _err
7687 }
7688 _err = dara.Convert(_body, &_result)
7689 return _result, _err
7690 }
7691
7692 // @param request - DescribeGtmInstanceSystemCnameRequest
7693 //
7694 // @return DescribeGtmInstanceSystemCnameResponse
7695 func DescribeGtmInstanceSystemCname(client *Client, request *DescribeGtmInstanceSystemCnameRequest) (_result *DescribeGtmInstanceSystemCnameResponse, _err error) {
7696 runtime := &dara.RuntimeOptions{}
7697 _result = &DescribeGtmInstanceSystemCnameResponse{}
7698 _body, _err := DescribeGtmInstanceSystemCnameWithOptions(client,request, runtime)
7699 if _err != nil {
7700 return _result, _err
7701 }
7702 _result = _body
7703 return _result, _err
7704 }
7705
7706 // Summary:
7707 //
7708 // Queries the Global Traffic Manager (GTM) instances under your account.
7709 //
7710 // @param request - DescribeGtmInstancesRequest
7711 //
7712 // @param runtime - runtime options for this request RuntimeOptions
7713 //
7714 // @return DescribeGtmInstancesResponse
7715 func DescribeGtmInstancesWithOptions(client *Client, request *DescribeGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstancesResponse, _err error) {
7716 if dara.BoolValue(client.EnableValidate) == true {
7717 _err = request.Validate()
7718 if _err != nil {
7719 return _result, _err
7720 }
7721 }
7722 query := map[string]interface{}{}
7723 if !dara.IsNil(request.Keyword) {
7724 query["Keyword"] = request.Keyword
7725 }
7726
7727 if !dara.IsNil(request.Lang) {
7728 query["Lang"] = request.Lang
7729 }
7730
7731 if !dara.IsNil(request.NeedDetailAttributes) {
7732 query["NeedDetailAttributes"] = request.NeedDetailAttributes
7733 }
7734
7735 if !dara.IsNil(request.PageNumber) {
7736 query["PageNumber"] = request.PageNumber
7737 }
7738
7739 if !dara.IsNil(request.PageSize) {
7740 query["PageSize"] = request.PageSize
7741 }
7742
7743 if !dara.IsNil(request.ResourceGroupId) {
7744 query["ResourceGroupId"] = request.ResourceGroupId
7745 }
7746
7747 req := &openapiutil.OpenApiRequest{
7748 Query: openapiutil.Query(query),
7749 }
7750 params := &openapiutil.Params{
7751 Action: dara.String("DescribeGtmInstances"),
7752 Version: dara.String("2015-01-09"),
7753 Protocol: dara.String("HTTPS"),
7754 Pathname: dara.String("/"),
7755 Method: dara.String("POST"),
7756 AuthType: dara.String("AK"),
7757 Style: dara.String("RPC"),
7758 ReqBodyType: dara.String("formData"),
7759 BodyType: dara.String("json"),
7760 }
7761 _result = &DescribeGtmInstancesResponse{}
7762 _body, _err := client.CallApi(params, req, runtime)
7763 if _err != nil {
7764 return _result, _err
7765 }
7766 _err = dara.Convert(_body, &_result)
7767 return _result, _err
7768 }
7769
7770 // Summary:
7771 //
7772 // Queries the Global Traffic Manager (GTM) instances under your account.
7773 //
7774 // @param request - DescribeGtmInstancesRequest
7775 //
7776 // @return DescribeGtmInstancesResponse
7777 func DescribeGtmInstances(client *Client, request *DescribeGtmInstancesRequest) (_result *DescribeGtmInstancesResponse, _err error) {
7778 runtime := &dara.RuntimeOptions{}
7779 _result = &DescribeGtmInstancesResponse{}
7780 _body, _err := DescribeGtmInstancesWithOptions(client,request, runtime)
7781 if _err != nil {
7782 return _result, _err
7783 }
7784 _result = _body
7785 return _result, _err
7786 }
7787
7788 // Summary:
7789 //
7790 // You can call this operation to query logs of a Global Traffic Manager (GTM) instance.
7791 //
7792 // @param request - DescribeGtmLogsRequest
7793 //
7794 // @param runtime - runtime options for this request RuntimeOptions
7795 //
7796 // @return DescribeGtmLogsResponse
7797 func DescribeGtmLogsWithOptions(client *Client, request *DescribeGtmLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmLogsResponse, _err error) {
7798 if dara.BoolValue(client.EnableValidate) == true {
7799 _err = request.Validate()
7800 if _err != nil {
7801 return _result, _err
7802 }
7803 }
7804 query := map[string]interface{}{}
7805 if !dara.IsNil(request.EndTimestamp) {
7806 query["EndTimestamp"] = request.EndTimestamp
7807 }
7808
7809 if !dara.IsNil(request.InstanceId) {
7810 query["InstanceId"] = request.InstanceId
7811 }
7812
7813 if !dara.IsNil(request.Keyword) {
7814 query["Keyword"] = request.Keyword
7815 }
7816
7817 if !dara.IsNil(request.Lang) {
7818 query["Lang"] = request.Lang
7819 }
7820
7821 if !dara.IsNil(request.PageNumber) {
7822 query["PageNumber"] = request.PageNumber
7823 }
7824
7825 if !dara.IsNil(request.PageSize) {
7826 query["PageSize"] = request.PageSize
7827 }
7828
7829 if !dara.IsNil(request.StartTimestamp) {
7830 query["StartTimestamp"] = request.StartTimestamp
7831 }
7832
7833 req := &openapiutil.OpenApiRequest{
7834 Query: openapiutil.Query(query),
7835 }
7836 params := &openapiutil.Params{
7837 Action: dara.String("DescribeGtmLogs"),
7838 Version: dara.String("2015-01-09"),
7839 Protocol: dara.String("HTTPS"),
7840 Pathname: dara.String("/"),
7841 Method: dara.String("POST"),
7842 AuthType: dara.String("AK"),
7843 Style: dara.String("RPC"),
7844 ReqBodyType: dara.String("formData"),
7845 BodyType: dara.String("json"),
7846 }
7847 _result = &DescribeGtmLogsResponse{}
7848 _body, _err := client.CallApi(params, req, runtime)
7849 if _err != nil {
7850 return _result, _err
7851 }
7852 _err = dara.Convert(_body, &_result)
7853 return _result, _err
7854 }
7855
7856 // Summary:
7857 //
7858 // You can call this operation to query logs of a Global Traffic Manager (GTM) instance.
7859 //
7860 // @param request - DescribeGtmLogsRequest
7861 //
7862 // @return DescribeGtmLogsResponse
7863 func DescribeGtmLogs(client *Client, request *DescribeGtmLogsRequest) (_result *DescribeGtmLogsResponse, _err error) {
7864 runtime := &dara.RuntimeOptions{}
7865 _result = &DescribeGtmLogsResponse{}
7866 _body, _err := DescribeGtmLogsWithOptions(client,request, runtime)
7867 if _err != nil {
7868 return _result, _err
7869 }
7870 _result = _body
7871 return _result, _err
7872 }
7873
7874 // Summary:
7875 //
7876 // Queries available monitored nodes.
7877 //
7878 // @param request - DescribeGtmMonitorAvailableConfigRequest
7879 //
7880 // @param runtime - runtime options for this request RuntimeOptions
7881 //
7882 // @return DescribeGtmMonitorAvailableConfigResponse
7883 func DescribeGtmMonitorAvailableConfigWithOptions(client *Client, request *DescribeGtmMonitorAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmMonitorAvailableConfigResponse, _err error) {
7884 if dara.BoolValue(client.EnableValidate) == true {
7885 _err = request.Validate()
7886 if _err != nil {
7887 return _result, _err
7888 }
7889 }
7890 query := map[string]interface{}{}
7891 if !dara.IsNil(request.Lang) {
7892 query["Lang"] = request.Lang
7893 }
7894
7895 req := &openapiutil.OpenApiRequest{
7896 Query: openapiutil.Query(query),
7897 }
7898 params := &openapiutil.Params{
7899 Action: dara.String("DescribeGtmMonitorAvailableConfig"),
7900 Version: dara.String("2015-01-09"),
7901 Protocol: dara.String("HTTPS"),
7902 Pathname: dara.String("/"),
7903 Method: dara.String("POST"),
7904 AuthType: dara.String("AK"),
7905 Style: dara.String("RPC"),
7906 ReqBodyType: dara.String("formData"),
7907 BodyType: dara.String("json"),
7908 }
7909 _result = &DescribeGtmMonitorAvailableConfigResponse{}
7910 _body, _err := client.CallApi(params, req, runtime)
7911 if _err != nil {
7912 return _result, _err
7913 }
7914 _err = dara.Convert(_body, &_result)
7915 return _result, _err
7916 }
7917
7918 // Summary:
7919 //
7920 // Queries available monitored nodes.
7921 //
7922 // @param request - DescribeGtmMonitorAvailableConfigRequest
7923 //
7924 // @return DescribeGtmMonitorAvailableConfigResponse
7925 func DescribeGtmMonitorAvailableConfig(client *Client, request *DescribeGtmMonitorAvailableConfigRequest) (_result *DescribeGtmMonitorAvailableConfigResponse, _err error) {
7926 runtime := &dara.RuntimeOptions{}
7927 _result = &DescribeGtmMonitorAvailableConfigResponse{}
7928 _body, _err := DescribeGtmMonitorAvailableConfigWithOptions(client,request, runtime)
7929 if _err != nil {
7930 return _result, _err
7931 }
7932 _result = _body
7933 return _result, _err
7934 }
7935
7936 // Summary:
7937 //
7938 // Queries the health check configuration of an address pool of a Global Traffic Manager (GTM) instance.
7939 //
7940 // @param request - DescribeGtmMonitorConfigRequest
7941 //
7942 // @param runtime - runtime options for this request RuntimeOptions
7943 //
7944 // @return DescribeGtmMonitorConfigResponse
7945 func DescribeGtmMonitorConfigWithOptions(client *Client, request *DescribeGtmMonitorConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmMonitorConfigResponse, _err error) {
7946 if dara.BoolValue(client.EnableValidate) == true {
7947 _err = request.Validate()
7948 if _err != nil {
7949 return _result, _err
7950 }
7951 }
7952 query := map[string]interface{}{}
7953 if !dara.IsNil(request.Lang) {
7954 query["Lang"] = request.Lang
7955 }
7956
7957 if !dara.IsNil(request.MonitorConfigId) {
7958 query["MonitorConfigId"] = request.MonitorConfigId
7959 }
7960
7961 req := &openapiutil.OpenApiRequest{
7962 Query: openapiutil.Query(query),
7963 }
7964 params := &openapiutil.Params{
7965 Action: dara.String("DescribeGtmMonitorConfig"),
7966 Version: dara.String("2015-01-09"),
7967 Protocol: dara.String("HTTPS"),
7968 Pathname: dara.String("/"),
7969 Method: dara.String("POST"),
7970 AuthType: dara.String("AK"),
7971 Style: dara.String("RPC"),
7972 ReqBodyType: dara.String("formData"),
7973 BodyType: dara.String("json"),
7974 }
7975 _result = &DescribeGtmMonitorConfigResponse{}
7976 _body, _err := client.CallApi(params, req, runtime)
7977 if _err != nil {
7978 return _result, _err
7979 }
7980 _err = dara.Convert(_body, &_result)
7981 return _result, _err
7982 }
7983
7984 // Summary:
7985 //
7986 // Queries the health check configuration of an address pool of a Global Traffic Manager (GTM) instance.
7987 //
7988 // @param request - DescribeGtmMonitorConfigRequest
7989 //
7990 // @return DescribeGtmMonitorConfigResponse
7991 func DescribeGtmMonitorConfig(client *Client, request *DescribeGtmMonitorConfigRequest) (_result *DescribeGtmMonitorConfigResponse, _err error) {
7992 runtime := &dara.RuntimeOptions{}
7993 _result = &DescribeGtmMonitorConfigResponse{}
7994 _body, _err := DescribeGtmMonitorConfigWithOptions(client,request, runtime)
7995 if _err != nil {
7996 return _result, _err
7997 }
7998 _result = _body
7999 return _result, _err
8000 }
8001
8002 // Summary:
8003 //
8004 // Queries the details of a disaster recovery plan.
8005 //
8006 // @param request - DescribeGtmRecoveryPlanRequest
8007 //
8008 // @param runtime - runtime options for this request RuntimeOptions
8009 //
8010 // @return DescribeGtmRecoveryPlanResponse
8011 func DescribeGtmRecoveryPlanWithOptions(client *Client, request *DescribeGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlanResponse, _err error) {
8012 if dara.BoolValue(client.EnableValidate) == true {
8013 _err = request.Validate()
8014 if _err != nil {
8015 return _result, _err
8016 }
8017 }
8018 query := map[string]interface{}{}
8019 if !dara.IsNil(request.Lang) {
8020 query["Lang"] = request.Lang
8021 }
8022
8023 if !dara.IsNil(request.RecoveryPlanId) {
8024 query["RecoveryPlanId"] = request.RecoveryPlanId
8025 }
8026
8027 req := &openapiutil.OpenApiRequest{
8028 Query: openapiutil.Query(query),
8029 }
8030 params := &openapiutil.Params{
8031 Action: dara.String("DescribeGtmRecoveryPlan"),
8032 Version: dara.String("2015-01-09"),
8033 Protocol: dara.String("HTTPS"),
8034 Pathname: dara.String("/"),
8035 Method: dara.String("POST"),
8036 AuthType: dara.String("AK"),
8037 Style: dara.String("RPC"),
8038 ReqBodyType: dara.String("formData"),
8039 BodyType: dara.String("json"),
8040 }
8041 _result = &DescribeGtmRecoveryPlanResponse{}
8042 _body, _err := client.CallApi(params, req, runtime)
8043 if _err != nil {
8044 return _result, _err
8045 }
8046 _err = dara.Convert(_body, &_result)
8047 return _result, _err
8048 }
8049
8050 // Summary:
8051 //
8052 // Queries the details of a disaster recovery plan.
8053 //
8054 // @param request - DescribeGtmRecoveryPlanRequest
8055 //
8056 // @return DescribeGtmRecoveryPlanResponse
8057 func DescribeGtmRecoveryPlan(client *Client, request *DescribeGtmRecoveryPlanRequest) (_result *DescribeGtmRecoveryPlanResponse, _err error) {
8058 runtime := &dara.RuntimeOptions{}
8059 _result = &DescribeGtmRecoveryPlanResponse{}
8060 _body, _err := DescribeGtmRecoveryPlanWithOptions(client,request, runtime)
8061 if _err != nil {
8062 return _result, _err
8063 }
8064 _result = _body
8065 return _result, _err
8066 }
8067
8068 // Summary:
8069 //
8070 // Queries the configuration items that can be set for a disaster recovery plan.
8071 //
8072 // @param request - DescribeGtmRecoveryPlanAvailableConfigRequest
8073 //
8074 // @param runtime - runtime options for this request RuntimeOptions
8075 //
8076 // @return DescribeGtmRecoveryPlanAvailableConfigResponse
8077 func DescribeGtmRecoveryPlanAvailableConfigWithOptions(client *Client, request *DescribeGtmRecoveryPlanAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlanAvailableConfigResponse, _err error) {
8078 if dara.BoolValue(client.EnableValidate) == true {
8079 _err = request.Validate()
8080 if _err != nil {
8081 return _result, _err
8082 }
8083 }
8084 query := map[string]interface{}{}
8085 if !dara.IsNil(request.Lang) {
8086 query["Lang"] = request.Lang
8087 }
8088
8089 req := &openapiutil.OpenApiRequest{
8090 Query: openapiutil.Query(query),
8091 }
8092 params := &openapiutil.Params{
8093 Action: dara.String("DescribeGtmRecoveryPlanAvailableConfig"),
8094 Version: dara.String("2015-01-09"),
8095 Protocol: dara.String("HTTPS"),
8096 Pathname: dara.String("/"),
8097 Method: dara.String("POST"),
8098 AuthType: dara.String("AK"),
8099 Style: dara.String("RPC"),
8100 ReqBodyType: dara.String("formData"),
8101 BodyType: dara.String("json"),
8102 }
8103 _result = &DescribeGtmRecoveryPlanAvailableConfigResponse{}
8104 _body, _err := client.CallApi(params, req, runtime)
8105 if _err != nil {
8106 return _result, _err
8107 }
8108 _err = dara.Convert(_body, &_result)
8109 return _result, _err
8110 }
8111
8112 // Summary:
8113 //
8114 // Queries the configuration items that can be set for a disaster recovery plan.
8115 //
8116 // @param request - DescribeGtmRecoveryPlanAvailableConfigRequest
8117 //
8118 // @return DescribeGtmRecoveryPlanAvailableConfigResponse
8119 func DescribeGtmRecoveryPlanAvailableConfig(client *Client, request *DescribeGtmRecoveryPlanAvailableConfigRequest) (_result *DescribeGtmRecoveryPlanAvailableConfigResponse, _err error) {
8120 runtime := &dara.RuntimeOptions{}
8121 _result = &DescribeGtmRecoveryPlanAvailableConfigResponse{}
8122 _body, _err := DescribeGtmRecoveryPlanAvailableConfigWithOptions(client,request, runtime)
8123 if _err != nil {
8124 return _result, _err
8125 }
8126 _result = _body
8127 return _result, _err
8128 }
8129
8130 // Summary:
8131 //
8132 // Queries the disaster recovery plans for a Global Traffic Manager (GTM) instance.
8133 //
8134 // @param request - DescribeGtmRecoveryPlansRequest
8135 //
8136 // @param runtime - runtime options for this request RuntimeOptions
8137 //
8138 // @return DescribeGtmRecoveryPlansResponse
8139 func DescribeGtmRecoveryPlansWithOptions(client *Client, request *DescribeGtmRecoveryPlansRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlansResponse, _err error) {
8140 if dara.BoolValue(client.EnableValidate) == true {
8141 _err = request.Validate()
8142 if _err != nil {
8143 return _result, _err
8144 }
8145 }
8146 query := map[string]interface{}{}
8147 if !dara.IsNil(request.Keyword) {
8148 query["Keyword"] = request.Keyword
8149 }
8150
8151 if !dara.IsNil(request.Lang) {
8152 query["Lang"] = request.Lang
8153 }
8154
8155 if !dara.IsNil(request.PageNumber) {
8156 query["PageNumber"] = request.PageNumber
8157 }
8158
8159 if !dara.IsNil(request.PageSize) {
8160 query["PageSize"] = request.PageSize
8161 }
8162
8163 req := &openapiutil.OpenApiRequest{
8164 Query: openapiutil.Query(query),
8165 }
8166 params := &openapiutil.Params{
8167 Action: dara.String("DescribeGtmRecoveryPlans"),
8168 Version: dara.String("2015-01-09"),
8169 Protocol: dara.String("HTTPS"),
8170 Pathname: dara.String("/"),
8171 Method: dara.String("POST"),
8172 AuthType: dara.String("AK"),
8173 Style: dara.String("RPC"),
8174 ReqBodyType: dara.String("formData"),
8175 BodyType: dara.String("json"),
8176 }
8177 _result = &DescribeGtmRecoveryPlansResponse{}
8178 _body, _err := client.CallApi(params, req, runtime)
8179 if _err != nil {
8180 return _result, _err
8181 }
8182 _err = dara.Convert(_body, &_result)
8183 return _result, _err
8184 }
8185
8186 // Summary:
8187 //
8188 // Queries the disaster recovery plans for a Global Traffic Manager (GTM) instance.
8189 //
8190 // @param request - DescribeGtmRecoveryPlansRequest
8191 //
8192 // @return DescribeGtmRecoveryPlansResponse
8193 func DescribeGtmRecoveryPlans(client *Client, request *DescribeGtmRecoveryPlansRequest) (_result *DescribeGtmRecoveryPlansResponse, _err error) {
8194 runtime := &dara.RuntimeOptions{}
8195 _result = &DescribeGtmRecoveryPlansResponse{}
8196 _body, _err := DescribeGtmRecoveryPlansWithOptions(client,request, runtime)
8197 if _err != nil {
8198 return _result, _err
8199 }
8200 _result = _body
8201 return _result, _err
8202 }
8203
8204 // Summary:
8205 //
8206 // Queries the domain names that are bound to an Alibaba Cloud DNS instance.
8207 //
8208 // @param request - DescribeInstanceDomainsRequest
8209 //
8210 // @param runtime - runtime options for this request RuntimeOptions
8211 //
8212 // @return DescribeInstanceDomainsResponse
8213 func DescribeInstanceDomainsWithOptions(client *Client, request *DescribeInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeInstanceDomainsResponse, _err error) {
8214 if dara.BoolValue(client.EnableValidate) == true {
8215 _err = request.Validate()
8216 if _err != nil {
8217 return _result, _err
8218 }
8219 }
8220 query := map[string]interface{}{}
8221 if !dara.IsNil(request.InstanceId) {
8222 query["InstanceId"] = request.InstanceId
8223 }
8224
8225 if !dara.IsNil(request.Lang) {
8226 query["Lang"] = request.Lang
8227 }
8228
8229 if !dara.IsNil(request.PageNumber) {
8230 query["PageNumber"] = request.PageNumber
8231 }
8232
8233 if !dara.IsNil(request.PageSize) {
8234 query["PageSize"] = request.PageSize
8235 }
8236
8237 req := &openapiutil.OpenApiRequest{
8238 Query: openapiutil.Query(query),
8239 }
8240 params := &openapiutil.Params{
8241 Action: dara.String("DescribeInstanceDomains"),
8242 Version: dara.String("2015-01-09"),
8243 Protocol: dara.String("HTTPS"),
8244 Pathname: dara.String("/"),
8245 Method: dara.String("POST"),
8246 AuthType: dara.String("AK"),
8247 Style: dara.String("RPC"),
8248 ReqBodyType: dara.String("formData"),
8249 BodyType: dara.String("json"),
8250 }
8251 _result = &DescribeInstanceDomainsResponse{}
8252 _body, _err := client.CallApi(params, req, runtime)
8253 if _err != nil {
8254 return _result, _err
8255 }
8256 _err = dara.Convert(_body, &_result)
8257 return _result, _err
8258 }
8259
8260 // Summary:
8261 //
8262 // Queries the domain names that are bound to an Alibaba Cloud DNS instance.
8263 //
8264 // @param request - DescribeInstanceDomainsRequest
8265 //
8266 // @return DescribeInstanceDomainsResponse
8267 func DescribeInstanceDomains(client *Client, request *DescribeInstanceDomainsRequest) (_result *DescribeInstanceDomainsResponse, _err error) {
8268 runtime := &dara.RuntimeOptions{}
8269 _result = &DescribeInstanceDomainsResponse{}
8270 _body, _err := DescribeInstanceDomainsWithOptions(client,request, runtime)
8271 if _err != nil {
8272 return _result, _err
8273 }
8274 _result = _body
8275 return _result, _err
8276 }
8277
8278 // Summary:
8279 //
8280 // 查询解析日志
8281 //
8282 // @param request - DescribeInternetDnsLogsRequest
8283 //
8284 // @param runtime - runtime options for this request RuntimeOptions
8285 //
8286 // @return DescribeInternetDnsLogsResponse
8287 func DescribeInternetDnsLogsWithOptions(client *Client, request *DescribeInternetDnsLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeInternetDnsLogsResponse, _err error) {
8288 if dara.BoolValue(client.EnableValidate) == true {
8289 _err = request.Validate()
8290 if _err != nil {
8291 return _result, _err
8292 }
8293 }
8294 query := map[string]interface{}{}
8295 if !dara.IsNil(request.AccountId) {
8296 query["AccountId"] = request.AccountId
8297 }
8298
8299 if !dara.IsNil(request.DomainName) {
8300 query["DomainName"] = request.DomainName
8301 }
8302
8303 if !dara.IsNil(request.EndTimestamp) {
8304 query["EndTimestamp"] = request.EndTimestamp
8305 }
8306
8307 if !dara.IsNil(request.Lang) {
8308 query["Lang"] = request.Lang
8309 }
8310
8311 if !dara.IsNil(request.Module) {
8312 query["Module"] = request.Module
8313 }
8314
8315 if !dara.IsNil(request.PageNumber) {
8316 query["PageNumber"] = request.PageNumber
8317 }
8318
8319 if !dara.IsNil(request.PageSize) {
8320 query["PageSize"] = request.PageSize
8321 }
8322
8323 if !dara.IsNil(request.QueryCondition) {
8324 query["QueryCondition"] = request.QueryCondition
8325 }
8326
8327 if !dara.IsNil(request.RecursionProtocolType) {
8328 query["RecursionProtocolType"] = request.RecursionProtocolType
8329 }
8330
8331 if !dara.IsNil(request.StartTimestamp) {
8332 query["StartTimestamp"] = request.StartTimestamp
8333 }
8334
8335 req := &openapiutil.OpenApiRequest{
8336 Query: openapiutil.Query(query),
8337 }
8338 params := &openapiutil.Params{
8339 Action: dara.String("DescribeInternetDnsLogs"),
8340 Version: dara.String("2015-01-09"),
8341 Protocol: dara.String("HTTPS"),
8342 Pathname: dara.String("/"),
8343 Method: dara.String("POST"),
8344 AuthType: dara.String("AK"),
8345 Style: dara.String("RPC"),
8346 ReqBodyType: dara.String("formData"),
8347 BodyType: dara.String("json"),
8348 }
8349 _result = &DescribeInternetDnsLogsResponse{}
8350 _body, _err := client.CallApi(params, req, runtime)
8351 if _err != nil {
8352 return _result, _err
8353 }
8354 _err = dara.Convert(_body, &_result)
8355 return _result, _err
8356 }
8357
8358 // Summary:
8359 //
8360 // 查询解析日志
8361 //
8362 // @param request - DescribeInternetDnsLogsRequest
8363 //
8364 // @return DescribeInternetDnsLogsResponse
8365 func DescribeInternetDnsLogs(client *Client, request *DescribeInternetDnsLogsRequest) (_result *DescribeInternetDnsLogsResponse, _err error) {
8366 runtime := &dara.RuntimeOptions{}
8367 _result = &DescribeInternetDnsLogsResponse{}
8368 _body, _err := DescribeInternetDnsLogsWithOptions(client,request, runtime)
8369 if _err != nil {
8370 return _result, _err
8371 }
8372 _result = _body
8373 return _result, _err
8374 }
8375
8376 // Summary:
8377 //
8378 // 获取缓存刷新套餐包列表
8379 //
8380 // @param request - DescribeIspFlushCacheInstancesRequest
8381 //
8382 // @param runtime - runtime options for this request RuntimeOptions
8383 //
8384 // @return DescribeIspFlushCacheInstancesResponse
8385 func DescribeIspFlushCacheInstancesWithOptions(client *Client, request *DescribeIspFlushCacheInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheInstancesResponse, _err error) {
8386 if dara.BoolValue(client.EnableValidate) == true {
8387 _err = request.Validate()
8388 if _err != nil {
8389 return _result, _err
8390 }
8391 }
8392 query := map[string]interface{}{}
8393 if !dara.IsNil(request.Direction) {
8394 query["Direction"] = request.Direction
8395 }
8396
8397 if !dara.IsNil(request.Isp) {
8398 query["Isp"] = request.Isp
8399 }
8400
8401 if !dara.IsNil(request.Keyword) {
8402 query["Keyword"] = request.Keyword
8403 }
8404
8405 if !dara.IsNil(request.Lang) {
8406 query["Lang"] = request.Lang
8407 }
8408
8409 if !dara.IsNil(request.OrderBy) {
8410 query["OrderBy"] = request.OrderBy
8411 }
8412
8413 if !dara.IsNil(request.PageNumber) {
8414 query["PageNumber"] = request.PageNumber
8415 }
8416
8417 if !dara.IsNil(request.PageSize) {
8418 query["PageSize"] = request.PageSize
8419 }
8420
8421 if !dara.IsNil(request.Type) {
8422 query["Type"] = request.Type
8423 }
8424
8425 req := &openapiutil.OpenApiRequest{
8426 Query: openapiutil.Query(query),
8427 }
8428 params := &openapiutil.Params{
8429 Action: dara.String("DescribeIspFlushCacheInstances"),
8430 Version: dara.String("2015-01-09"),
8431 Protocol: dara.String("HTTPS"),
8432 Pathname: dara.String("/"),
8433 Method: dara.String("POST"),
8434 AuthType: dara.String("AK"),
8435 Style: dara.String("RPC"),
8436 ReqBodyType: dara.String("formData"),
8437 BodyType: dara.String("json"),
8438 }
8439 _result = &DescribeIspFlushCacheInstancesResponse{}
8440 _body, _err := client.CallApi(params, req, runtime)
8441 if _err != nil {
8442 return _result, _err
8443 }
8444 _err = dara.Convert(_body, &_result)
8445 return _result, _err
8446 }
8447
8448 // Summary:
8449 //
8450 // 获取缓存刷新套餐包列表
8451 //
8452 // @param request - DescribeIspFlushCacheInstancesRequest
8453 //
8454 // @return DescribeIspFlushCacheInstancesResponse
8455 func DescribeIspFlushCacheInstances(client *Client, request *DescribeIspFlushCacheInstancesRequest) (_result *DescribeIspFlushCacheInstancesResponse, _err error) {
8456 runtime := &dara.RuntimeOptions{}
8457 _result = &DescribeIspFlushCacheInstancesResponse{}
8458 _body, _err := DescribeIspFlushCacheInstancesWithOptions(client,request, runtime)
8459 if _err != nil {
8460 return _result, _err
8461 }
8462 _result = _body
8463 return _result, _err
8464 }
8465
8466 // Summary:
8467 //
8468 // 获取剩余可缓存刷新次数
8469 //
8470 // @param request - DescribeIspFlushCacheRemainQuotaRequest
8471 //
8472 // @param runtime - runtime options for this request RuntimeOptions
8473 //
8474 // @return DescribeIspFlushCacheRemainQuotaResponse
8475 func DescribeIspFlushCacheRemainQuotaWithOptions(client *Client, request *DescribeIspFlushCacheRemainQuotaRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheRemainQuotaResponse, _err error) {
8476 if dara.BoolValue(client.EnableValidate) == true {
8477 _err = request.Validate()
8478 if _err != nil {
8479 return _result, _err
8480 }
8481 }
8482 query := map[string]interface{}{}
8483 if !dara.IsNil(request.Lang) {
8484 query["Lang"] = request.Lang
8485 }
8486
8487 req := &openapiutil.OpenApiRequest{
8488 Query: openapiutil.Query(query),
8489 }
8490 params := &openapiutil.Params{
8491 Action: dara.String("DescribeIspFlushCacheRemainQuota"),
8492 Version: dara.String("2015-01-09"),
8493 Protocol: dara.String("HTTPS"),
8494 Pathname: dara.String("/"),
8495 Method: dara.String("POST"),
8496 AuthType: dara.String("AK"),
8497 Style: dara.String("RPC"),
8498 ReqBodyType: dara.String("formData"),
8499 BodyType: dara.String("json"),
8500 }
8501 _result = &DescribeIspFlushCacheRemainQuotaResponse{}
8502 _body, _err := client.CallApi(params, req, runtime)
8503 if _err != nil {
8504 return _result, _err
8505 }
8506 _err = dara.Convert(_body, &_result)
8507 return _result, _err
8508 }
8509
8510 // Summary:
8511 //
8512 // 获取剩余可缓存刷新次数
8513 //
8514 // @param request - DescribeIspFlushCacheRemainQuotaRequest
8515 //
8516 // @return DescribeIspFlushCacheRemainQuotaResponse
8517 func DescribeIspFlushCacheRemainQuota(client *Client, request *DescribeIspFlushCacheRemainQuotaRequest) (_result *DescribeIspFlushCacheRemainQuotaResponse, _err error) {
8518 runtime := &dara.RuntimeOptions{}
8519 _result = &DescribeIspFlushCacheRemainQuotaResponse{}
8520 _body, _err := DescribeIspFlushCacheRemainQuotaWithOptions(client,request, runtime)
8521 if _err != nil {
8522 return _result, _err
8523 }
8524 _result = _body
8525 return _result, _err
8526 }
8527
8528 // Summary:
8529 //
8530 // 获取缓存刷新任务详情
8531 //
8532 // @param request - DescribeIspFlushCacheTaskRequest
8533 //
8534 // @param runtime - runtime options for this request RuntimeOptions
8535 //
8536 // @return DescribeIspFlushCacheTaskResponse
8537 func DescribeIspFlushCacheTaskWithOptions(client *Client, request *DescribeIspFlushCacheTaskRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheTaskResponse, _err error) {
8538 if dara.BoolValue(client.EnableValidate) == true {
8539 _err = request.Validate()
8540 if _err != nil {
8541 return _result, _err
8542 }
8543 }
8544 query := map[string]interface{}{}
8545 if !dara.IsNil(request.Lang) {
8546 query["Lang"] = request.Lang
8547 }
8548
8549 if !dara.IsNil(request.TaskId) {
8550 query["TaskId"] = request.TaskId
8551 }
8552
8553 req := &openapiutil.OpenApiRequest{
8554 Query: openapiutil.Query(query),
8555 }
8556 params := &openapiutil.Params{
8557 Action: dara.String("DescribeIspFlushCacheTask"),
8558 Version: dara.String("2015-01-09"),
8559 Protocol: dara.String("HTTPS"),
8560 Pathname: dara.String("/"),
8561 Method: dara.String("POST"),
8562 AuthType: dara.String("AK"),
8563 Style: dara.String("RPC"),
8564 ReqBodyType: dara.String("formData"),
8565 BodyType: dara.String("json"),
8566 }
8567 _result = &DescribeIspFlushCacheTaskResponse{}
8568 _body, _err := client.CallApi(params, req, runtime)
8569 if _err != nil {
8570 return _result, _err
8571 }
8572 _err = dara.Convert(_body, &_result)
8573 return _result, _err
8574 }
8575
8576 // Summary:
8577 //
8578 // 获取缓存刷新任务详情
8579 //
8580 // @param request - DescribeIspFlushCacheTaskRequest
8581 //
8582 // @return DescribeIspFlushCacheTaskResponse
8583 func DescribeIspFlushCacheTask(client *Client, request *DescribeIspFlushCacheTaskRequest) (_result *DescribeIspFlushCacheTaskResponse, _err error) {
8584 runtime := &dara.RuntimeOptions{}
8585 _result = &DescribeIspFlushCacheTaskResponse{}
8586 _body, _err := DescribeIspFlushCacheTaskWithOptions(client,request, runtime)
8587 if _err != nil {
8588 return _result, _err
8589 }
8590 _result = _body
8591 return _result, _err
8592 }
8593
8594 // Summary:
8595 //
8596 // 获取缓存刷新任务列表
8597 //
8598 // @param request - DescribeIspFlushCacheTasksRequest
8599 //
8600 // @param runtime - runtime options for this request RuntimeOptions
8601 //
8602 // @return DescribeIspFlushCacheTasksResponse
8603 func DescribeIspFlushCacheTasksWithOptions(client *Client, request *DescribeIspFlushCacheTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheTasksResponse, _err error) {
8604 if dara.BoolValue(client.EnableValidate) == true {
8605 _err = request.Validate()
8606 if _err != nil {
8607 return _result, _err
8608 }
8609 }
8610 query := map[string]interface{}{}
8611 if !dara.IsNil(request.Direction) {
8612 query["Direction"] = request.Direction
8613 }
8614
8615 if !dara.IsNil(request.DomainName) {
8616 query["DomainName"] = request.DomainName
8617 }
8618
8619 if !dara.IsNil(request.InstanceId) {
8620 query["InstanceId"] = request.InstanceId
8621 }
8622
8623 if !dara.IsNil(request.Isp) {
8624 query["Isp"] = request.Isp
8625 }
8626
8627 if !dara.IsNil(request.Lang) {
8628 query["Lang"] = request.Lang
8629 }
8630
8631 if !dara.IsNil(request.OrderBy) {
8632 query["OrderBy"] = request.OrderBy
8633 }
8634
8635 if !dara.IsNil(request.PageNumber) {
8636 query["PageNumber"] = request.PageNumber
8637 }
8638
8639 if !dara.IsNil(request.PageSize) {
8640 query["PageSize"] = request.PageSize
8641 }
8642
8643 req := &openapiutil.OpenApiRequest{
8644 Query: openapiutil.Query(query),
8645 }
8646 params := &openapiutil.Params{
8647 Action: dara.String("DescribeIspFlushCacheTasks"),
8648 Version: dara.String("2015-01-09"),
8649 Protocol: dara.String("HTTPS"),
8650 Pathname: dara.String("/"),
8651 Method: dara.String("POST"),
8652 AuthType: dara.String("AK"),
8653 Style: dara.String("RPC"),
8654 ReqBodyType: dara.String("formData"),
8655 BodyType: dara.String("json"),
8656 }
8657 _result = &DescribeIspFlushCacheTasksResponse{}
8658 _body, _err := client.CallApi(params, req, runtime)
8659 if _err != nil {
8660 return _result, _err
8661 }
8662 _err = dara.Convert(_body, &_result)
8663 return _result, _err
8664 }
8665
8666 // Summary:
8667 //
8668 // 获取缓存刷新任务列表
8669 //
8670 // @param request - DescribeIspFlushCacheTasksRequest
8671 //
8672 // @return DescribeIspFlushCacheTasksResponse
8673 func DescribeIspFlushCacheTasks(client *Client, request *DescribeIspFlushCacheTasksRequest) (_result *DescribeIspFlushCacheTasksResponse, _err error) {
8674 runtime := &dara.RuntimeOptions{}
8675 _result = &DescribeIspFlushCacheTasksResponse{}
8676 _body, _err := DescribeIspFlushCacheTasksWithOptions(client,request, runtime)
8677 if _err != nil {
8678 return _result, _err
8679 }
8680 _result = _body
8681 return _result, _err
8682 }
8683
8684 // Summary:
8685 //
8686 // 获取公共DNS用户数据概览
8687 //
8688 // @param request - DescribePdnsAccountSummaryRequest
8689 //
8690 // @param runtime - runtime options for this request RuntimeOptions
8691 //
8692 // @return DescribePdnsAccountSummaryResponse
8693 func DescribePdnsAccountSummaryWithOptions(client *Client, request *DescribePdnsAccountSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAccountSummaryResponse, _err error) {
8694 if dara.BoolValue(client.EnableValidate) == true {
8695 _err = request.Validate()
8696 if _err != nil {
8697 return _result, _err
8698 }
8699 }
8700 query := map[string]interface{}{}
8701 if !dara.IsNil(request.EndDate) {
8702 query["EndDate"] = request.EndDate
8703 }
8704
8705 if !dara.IsNil(request.Lang) {
8706 query["Lang"] = request.Lang
8707 }
8708
8709 if !dara.IsNil(request.StartDate) {
8710 query["StartDate"] = request.StartDate
8711 }
8712
8713 req := &openapiutil.OpenApiRequest{
8714 Query: openapiutil.Query(query),
8715 }
8716 params := &openapiutil.Params{
8717 Action: dara.String("DescribePdnsAccountSummary"),
8718 Version: dara.String("2015-01-09"),
8719 Protocol: dara.String("HTTPS"),
8720 Pathname: dara.String("/"),
8721 Method: dara.String("POST"),
8722 AuthType: dara.String("AK"),
8723 Style: dara.String("RPC"),
8724 ReqBodyType: dara.String("formData"),
8725 BodyType: dara.String("json"),
8726 }
8727 _result = &DescribePdnsAccountSummaryResponse{}
8728 _body, _err := client.CallApi(params, req, runtime)
8729 if _err != nil {
8730 return _result, _err
8731 }
8732 _err = dara.Convert(_body, &_result)
8733 return _result, _err
8734 }
8735
8736 // Summary:
8737 //
8738 // 获取公共DNS用户数据概览
8739 //
8740 // @param request - DescribePdnsAccountSummaryRequest
8741 //
8742 // @return DescribePdnsAccountSummaryResponse
8743 func DescribePdnsAccountSummary(client *Client, request *DescribePdnsAccountSummaryRequest) (_result *DescribePdnsAccountSummaryResponse, _err error) {
8744 runtime := &dara.RuntimeOptions{}
8745 _result = &DescribePdnsAccountSummaryResponse{}
8746 _body, _err := DescribePdnsAccountSummaryWithOptions(client,request, runtime)
8747 if _err != nil {
8748 return _result, _err
8749 }
8750 _result = _body
8751 return _result, _err
8752 }
8753
8754 // Summary:
8755 //
8756 // 获取公共DNS AppKey 详情
8757 //
8758 // @param request - DescribePdnsAppKeyRequest
8759 //
8760 // @param runtime - runtime options for this request RuntimeOptions
8761 //
8762 // @return DescribePdnsAppKeyResponse
8763 func DescribePdnsAppKeyWithOptions(client *Client, request *DescribePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAppKeyResponse, _err error) {
8764 if dara.BoolValue(client.EnableValidate) == true {
8765 _err = request.Validate()
8766 if _err != nil {
8767 return _result, _err
8768 }
8769 }
8770 query := map[string]interface{}{}
8771 if !dara.IsNil(request.AppKeyId) {
8772 query["AppKeyId"] = request.AppKeyId
8773 }
8774
8775 if !dara.IsNil(request.AuthCode) {
8776 query["AuthCode"] = request.AuthCode
8777 }
8778
8779 if !dara.IsNil(request.Lang) {
8780 query["Lang"] = request.Lang
8781 }
8782
8783 req := &openapiutil.OpenApiRequest{
8784 Query: openapiutil.Query(query),
8785 }
8786 params := &openapiutil.Params{
8787 Action: dara.String("DescribePdnsAppKey"),
8788 Version: dara.String("2015-01-09"),
8789 Protocol: dara.String("HTTPS"),
8790 Pathname: dara.String("/"),
8791 Method: dara.String("POST"),
8792 AuthType: dara.String("AK"),
8793 Style: dara.String("RPC"),
8794 ReqBodyType: dara.String("formData"),
8795 BodyType: dara.String("json"),
8796 }
8797 _result = &DescribePdnsAppKeyResponse{}
8798 _body, _err := client.CallApi(params, req, runtime)
8799 if _err != nil {
8800 return _result, _err
8801 }
8802 _err = dara.Convert(_body, &_result)
8803 return _result, _err
8804 }
8805
8806 // Summary:
8807 //
8808 // 获取公共DNS AppKey 详情
8809 //
8810 // @param request - DescribePdnsAppKeyRequest
8811 //
8812 // @return DescribePdnsAppKeyResponse
8813 func DescribePdnsAppKey(client *Client, request *DescribePdnsAppKeyRequest) (_result *DescribePdnsAppKeyResponse, _err error) {
8814 runtime := &dara.RuntimeOptions{}
8815 _result = &DescribePdnsAppKeyResponse{}
8816 _body, _err := DescribePdnsAppKeyWithOptions(client,request, runtime)
8817 if _err != nil {
8818 return _result, _err
8819 }
8820 _result = _body
8821 return _result, _err
8822 }
8823
8824 // Summary:
8825 //
8826 // 获取公共DNS AppKey 列表
8827 //
8828 // @param request - DescribePdnsAppKeysRequest
8829 //
8830 // @param runtime - runtime options for this request RuntimeOptions
8831 //
8832 // @return DescribePdnsAppKeysResponse
8833 func DescribePdnsAppKeysWithOptions(client *Client, request *DescribePdnsAppKeysRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAppKeysResponse, _err error) {
8834 if dara.BoolValue(client.EnableValidate) == true {
8835 _err = request.Validate()
8836 if _err != nil {
8837 return _result, _err
8838 }
8839 }
8840 query := map[string]interface{}{}
8841 if !dara.IsNil(request.Lang) {
8842 query["Lang"] = request.Lang
8843 }
8844
8845 req := &openapiutil.OpenApiRequest{
8846 Query: openapiutil.Query(query),
8847 }
8848 params := &openapiutil.Params{
8849 Action: dara.String("DescribePdnsAppKeys"),
8850 Version: dara.String("2015-01-09"),
8851 Protocol: dara.String("HTTPS"),
8852 Pathname: dara.String("/"),
8853 Method: dara.String("POST"),
8854 AuthType: dara.String("AK"),
8855 Style: dara.String("RPC"),
8856 ReqBodyType: dara.String("formData"),
8857 BodyType: dara.String("json"),
8858 }
8859 _result = &DescribePdnsAppKeysResponse{}
8860 _body, _err := client.CallApi(params, req, runtime)
8861 if _err != nil {
8862 return _result, _err
8863 }
8864 _err = dara.Convert(_body, &_result)
8865 return _result, _err
8866 }
8867
8868 // Summary:
8869 //
8870 // 获取公共DNS AppKey 列表
8871 //
8872 // @param request - DescribePdnsAppKeysRequest
8873 //
8874 // @return DescribePdnsAppKeysResponse
8875 func DescribePdnsAppKeys(client *Client, request *DescribePdnsAppKeysRequest) (_result *DescribePdnsAppKeysResponse, _err error) {
8876 runtime := &dara.RuntimeOptions{}
8877 _result = &DescribePdnsAppKeysResponse{}
8878 _body, _err := DescribePdnsAppKeysWithOptions(client,request, runtime)
8879 if _err != nil {
8880 return _result, _err
8881 }
8882 _result = _body
8883 return _result, _err
8884 }
8885
8886 // Summary:
8887 //
8888 // 获取公共DNS 操作日志列表
8889 //
8890 // @param request - DescribePdnsOperateLogsRequest
8891 //
8892 // @param runtime - runtime options for this request RuntimeOptions
8893 //
8894 // @return DescribePdnsOperateLogsResponse
8895 func DescribePdnsOperateLogsWithOptions(client *Client, request *DescribePdnsOperateLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsOperateLogsResponse, _err error) {
8896 if dara.BoolValue(client.EnableValidate) == true {
8897 _err = request.Validate()
8898 if _err != nil {
8899 return _result, _err
8900 }
8901 }
8902 query := map[string]interface{}{}
8903 if !dara.IsNil(request.ActionType) {
8904 query["ActionType"] = request.ActionType
8905 }
8906
8907 if !dara.IsNil(request.EndDate) {
8908 query["EndDate"] = request.EndDate
8909 }
8910
8911 if !dara.IsNil(request.Keyword) {
8912 query["Keyword"] = request.Keyword
8913 }
8914
8915 if !dara.IsNil(request.Lang) {
8916 query["Lang"] = request.Lang
8917 }
8918
8919 if !dara.IsNil(request.PageNumber) {
8920 query["PageNumber"] = request.PageNumber
8921 }
8922
8923 if !dara.IsNil(request.PageSize) {
8924 query["PageSize"] = request.PageSize
8925 }
8926
8927 if !dara.IsNil(request.ResourceType) {
8928 query["ResourceType"] = request.ResourceType
8929 }
8930
8931 if !dara.IsNil(request.StartDate) {
8932 query["StartDate"] = request.StartDate
8933 }
8934
8935 req := &openapiutil.OpenApiRequest{
8936 Query: openapiutil.Query(query),
8937 }
8938 params := &openapiutil.Params{
8939 Action: dara.String("DescribePdnsOperateLogs"),
8940 Version: dara.String("2015-01-09"),
8941 Protocol: dara.String("HTTPS"),
8942 Pathname: dara.String("/"),
8943 Method: dara.String("POST"),
8944 AuthType: dara.String("AK"),
8945 Style: dara.String("RPC"),
8946 ReqBodyType: dara.String("formData"),
8947 BodyType: dara.String("json"),
8948 }
8949 _result = &DescribePdnsOperateLogsResponse{}
8950 _body, _err := client.CallApi(params, req, runtime)
8951 if _err != nil {
8952 return _result, _err
8953 }
8954 _err = dara.Convert(_body, &_result)
8955 return _result, _err
8956 }
8957
8958 // Summary:
8959 //
8960 // 获取公共DNS 操作日志列表
8961 //
8962 // @param request - DescribePdnsOperateLogsRequest
8963 //
8964 // @return DescribePdnsOperateLogsResponse
8965 func DescribePdnsOperateLogs(client *Client, request *DescribePdnsOperateLogsRequest) (_result *DescribePdnsOperateLogsResponse, _err error) {
8966 runtime := &dara.RuntimeOptions{}
8967 _result = &DescribePdnsOperateLogsResponse{}
8968 _body, _err := DescribePdnsOperateLogsWithOptions(client,request, runtime)
8969 if _err != nil {
8970 return _result, _err
8971 }
8972 _result = _body
8973 return _result, _err
8974 }
8975
8976 // Summary:
8977 //
8978 // Queries the statistics on requests for Alibaba Cloud Public DNS.
8979 //
8980 // @param request - DescribePdnsRequestStatisticRequest
8981 //
8982 // @param runtime - runtime options for this request RuntimeOptions
8983 //
8984 // @return DescribePdnsRequestStatisticResponse
8985 func DescribePdnsRequestStatisticWithOptions(client *Client, request *DescribePdnsRequestStatisticRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsRequestStatisticResponse, _err error) {
8986 if dara.BoolValue(client.EnableValidate) == true {
8987 _err = request.Validate()
8988 if _err != nil {
8989 return _result, _err
8990 }
8991 }
8992 query := map[string]interface{}{}
8993 if !dara.IsNil(request.DomainName) {
8994 query["DomainName"] = request.DomainName
8995 }
8996
8997 if !dara.IsNil(request.EndDate) {
8998 query["EndDate"] = request.EndDate
8999 }
9000
9001 if !dara.IsNil(request.Lang) {
9002 query["Lang"] = request.Lang
9003 }
9004
9005 if !dara.IsNil(request.StartDate) {
9006 query["StartDate"] = request.StartDate
9007 }
9008
9009 if !dara.IsNil(request.SubDomain) {
9010 query["SubDomain"] = request.SubDomain
9011 }
9012
9013 if !dara.IsNil(request.Type) {
9014 query["Type"] = request.Type
9015 }
9016
9017 req := &openapiutil.OpenApiRequest{
9018 Query: openapiutil.Query(query),
9019 }
9020 params := &openapiutil.Params{
9021 Action: dara.String("DescribePdnsRequestStatistic"),
9022 Version: dara.String("2015-01-09"),
9023 Protocol: dara.String("HTTPS"),
9024 Pathname: dara.String("/"),
9025 Method: dara.String("POST"),
9026 AuthType: dara.String("AK"),
9027 Style: dara.String("RPC"),
9028 ReqBodyType: dara.String("formData"),
9029 BodyType: dara.String("json"),
9030 }
9031 _result = &DescribePdnsRequestStatisticResponse{}
9032 _body, _err := client.CallApi(params, req, runtime)
9033 if _err != nil {
9034 return _result, _err
9035 }
9036 _err = dara.Convert(_body, &_result)
9037 return _result, _err
9038 }
9039
9040 // Summary:
9041 //
9042 // Queries the statistics on requests for Alibaba Cloud Public DNS.
9043 //
9044 // @param request - DescribePdnsRequestStatisticRequest
9045 //
9046 // @return DescribePdnsRequestStatisticResponse
9047 func DescribePdnsRequestStatistic(client *Client, request *DescribePdnsRequestStatisticRequest) (_result *DescribePdnsRequestStatisticResponse, _err error) {
9048 runtime := &dara.RuntimeOptions{}
9049 _result = &DescribePdnsRequestStatisticResponse{}
9050 _body, _err := DescribePdnsRequestStatisticWithOptions(client,request, runtime)
9051 if _err != nil {
9052 return _result, _err
9053 }
9054 _result = _body
9055 return _result, _err
9056 }
9057
9058 // Summary:
9059 //
9060 // Queries a list of statistics on requests for Alibaba Cloud Public DNS.
9061 //
9062 // @param request - DescribePdnsRequestStatisticsRequest
9063 //
9064 // @param runtime - runtime options for this request RuntimeOptions
9065 //
9066 // @return DescribePdnsRequestStatisticsResponse
9067 func DescribePdnsRequestStatisticsWithOptions(client *Client, request *DescribePdnsRequestStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsRequestStatisticsResponse, _err error) {
9068 if dara.BoolValue(client.EnableValidate) == true {
9069 _err = request.Validate()
9070 if _err != nil {
9071 return _result, _err
9072 }
9073 }
9074 query := map[string]interface{}{}
9075 if !dara.IsNil(request.DomainName) {
9076 query["DomainName"] = request.DomainName
9077 }
9078
9079 if !dara.IsNil(request.EndDate) {
9080 query["EndDate"] = request.EndDate
9081 }
9082
9083 if !dara.IsNil(request.Lang) {
9084 query["Lang"] = request.Lang
9085 }
9086
9087 if !dara.IsNil(request.PageNumber) {
9088 query["PageNumber"] = request.PageNumber
9089 }
9090
9091 if !dara.IsNil(request.PageSize) {
9092 query["PageSize"] = request.PageSize
9093 }
9094
9095 if !dara.IsNil(request.StartDate) {
9096 query["StartDate"] = request.StartDate
9097 }
9098
9099 if !dara.IsNil(request.SubDomain) {
9100 query["SubDomain"] = request.SubDomain
9101 }
9102
9103 if !dara.IsNil(request.Type) {
9104 query["Type"] = request.Type
9105 }
9106
9107 req := &openapiutil.OpenApiRequest{
9108 Query: openapiutil.Query(query),
9109 }
9110 params := &openapiutil.Params{
9111 Action: dara.String("DescribePdnsRequestStatistics"),
9112 Version: dara.String("2015-01-09"),
9113 Protocol: dara.String("HTTPS"),
9114 Pathname: dara.String("/"),
9115 Method: dara.String("POST"),
9116 AuthType: dara.String("AK"),
9117 Style: dara.String("RPC"),
9118 ReqBodyType: dara.String("formData"),
9119 BodyType: dara.String("json"),
9120 }
9121 _result = &DescribePdnsRequestStatisticsResponse{}
9122 _body, _err := client.CallApi(params, req, runtime)
9123 if _err != nil {
9124 return _result, _err
9125 }
9126 _err = dara.Convert(_body, &_result)
9127 return _result, _err
9128 }
9129
9130 // Summary:
9131 //
9132 // Queries a list of statistics on requests for Alibaba Cloud Public DNS.
9133 //
9134 // @param request - DescribePdnsRequestStatisticsRequest
9135 //
9136 // @return DescribePdnsRequestStatisticsResponse
9137 func DescribePdnsRequestStatistics(client *Client, request *DescribePdnsRequestStatisticsRequest) (_result *DescribePdnsRequestStatisticsResponse, _err error) {
9138 runtime := &dara.RuntimeOptions{}
9139 _result = &DescribePdnsRequestStatisticsResponse{}
9140 _body, _err := DescribePdnsRequestStatisticsWithOptions(client,request, runtime)
9141 if _err != nil {
9142 return _result, _err
9143 }
9144 _result = _body
9145 return _result, _err
9146 }
9147
9148 // Summary:
9149 //
9150 // 获取公共DNS 威胁日志列表
9151 //
9152 // @param request - DescribePdnsThreatLogsRequest
9153 //
9154 // @param runtime - runtime options for this request RuntimeOptions
9155 //
9156 // @return DescribePdnsThreatLogsResponse
9157 func DescribePdnsThreatLogsWithOptions(client *Client, request *DescribePdnsThreatLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatLogsResponse, _err error) {
9158 if dara.BoolValue(client.EnableValidate) == true {
9159 _err = request.Validate()
9160 if _err != nil {
9161 return _result, _err
9162 }
9163 }
9164 query := map[string]interface{}{}
9165 if !dara.IsNil(request.EndDate) {
9166 query["EndDate"] = request.EndDate
9167 }
9168
9169 if !dara.IsNil(request.Keyword) {
9170 query["Keyword"] = request.Keyword
9171 }
9172
9173 if !dara.IsNil(request.Lang) {
9174 query["Lang"] = request.Lang
9175 }
9176
9177 if !dara.IsNil(request.PageNumber) {
9178 query["PageNumber"] = request.PageNumber
9179 }
9180
9181 if !dara.IsNil(request.PageSize) {
9182 query["PageSize"] = request.PageSize
9183 }
9184
9185 if !dara.IsNil(request.StartDate) {
9186 query["StartDate"] = request.StartDate
9187 }
9188
9189 if !dara.IsNil(request.ThreatLevel) {
9190 query["ThreatLevel"] = request.ThreatLevel
9191 }
9192
9193 if !dara.IsNil(request.ThreatSourceIp) {
9194 query["ThreatSourceIp"] = request.ThreatSourceIp
9195 }
9196
9197 if !dara.IsNil(request.ThreatType) {
9198 query["ThreatType"] = request.ThreatType
9199 }
9200
9201 req := &openapiutil.OpenApiRequest{
9202 Query: openapiutil.Query(query),
9203 }
9204 params := &openapiutil.Params{
9205 Action: dara.String("DescribePdnsThreatLogs"),
9206 Version: dara.String("2015-01-09"),
9207 Protocol: dara.String("HTTPS"),
9208 Pathname: dara.String("/"),
9209 Method: dara.String("POST"),
9210 AuthType: dara.String("AK"),
9211 Style: dara.String("RPC"),
9212 ReqBodyType: dara.String("formData"),
9213 BodyType: dara.String("json"),
9214 }
9215 _result = &DescribePdnsThreatLogsResponse{}
9216 _body, _err := client.CallApi(params, req, runtime)
9217 if _err != nil {
9218 return _result, _err
9219 }
9220 _err = dara.Convert(_body, &_result)
9221 return _result, _err
9222 }
9223
9224 // Summary:
9225 //
9226 // 获取公共DNS 威胁日志列表
9227 //
9228 // @param request - DescribePdnsThreatLogsRequest
9229 //
9230 // @return DescribePdnsThreatLogsResponse
9231 func DescribePdnsThreatLogs(client *Client, request *DescribePdnsThreatLogsRequest) (_result *DescribePdnsThreatLogsResponse, _err error) {
9232 runtime := &dara.RuntimeOptions{}
9233 _result = &DescribePdnsThreatLogsResponse{}
9234 _body, _err := DescribePdnsThreatLogsWithOptions(client,request, runtime)
9235 if _err != nil {
9236 return _result, _err
9237 }
9238 _result = _body
9239 return _result, _err
9240 }
9241
9242 // Summary:
9243 //
9244 // 获取公共DNS 威胁统计
9245 //
9246 // @param request - DescribePdnsThreatStatisticRequest
9247 //
9248 // @param runtime - runtime options for this request RuntimeOptions
9249 //
9250 // @return DescribePdnsThreatStatisticResponse
9251 func DescribePdnsThreatStatisticWithOptions(client *Client, request *DescribePdnsThreatStatisticRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatStatisticResponse, _err error) {
9252 if dara.BoolValue(client.EnableValidate) == true {
9253 _err = request.Validate()
9254 if _err != nil {
9255 return _result, _err
9256 }
9257 }
9258 query := map[string]interface{}{}
9259 if !dara.IsNil(request.EndDate) {
9260 query["EndDate"] = request.EndDate
9261 }
9262
9263 if !dara.IsNil(request.Lang) {
9264 query["Lang"] = request.Lang
9265 }
9266
9267 if !dara.IsNil(request.StartDate) {
9268 query["StartDate"] = request.StartDate
9269 }
9270
9271 if !dara.IsNil(request.ThreatSourceIp) {
9272 query["ThreatSourceIp"] = request.ThreatSourceIp
9273 }
9274
9275 req := &openapiutil.OpenApiRequest{
9276 Query: openapiutil.Query(query),
9277 }
9278 params := &openapiutil.Params{
9279 Action: dara.String("DescribePdnsThreatStatistic"),
9280 Version: dara.String("2015-01-09"),
9281 Protocol: dara.String("HTTPS"),
9282 Pathname: dara.String("/"),
9283 Method: dara.String("POST"),
9284 AuthType: dara.String("AK"),
9285 Style: dara.String("RPC"),
9286 ReqBodyType: dara.String("formData"),
9287 BodyType: dara.String("json"),
9288 }
9289 _result = &DescribePdnsThreatStatisticResponse{}
9290 _body, _err := client.CallApi(params, req, runtime)
9291 if _err != nil {
9292 return _result, _err
9293 }
9294 _err = dara.Convert(_body, &_result)
9295 return _result, _err
9296 }
9297
9298 // Summary:
9299 //
9300 // 获取公共DNS 威胁统计
9301 //
9302 // @param request - DescribePdnsThreatStatisticRequest
9303 //
9304 // @return DescribePdnsThreatStatisticResponse
9305 func DescribePdnsThreatStatistic(client *Client, request *DescribePdnsThreatStatisticRequest) (_result *DescribePdnsThreatStatisticResponse, _err error) {
9306 runtime := &dara.RuntimeOptions{}
9307 _result = &DescribePdnsThreatStatisticResponse{}
9308 _body, _err := DescribePdnsThreatStatisticWithOptions(client,request, runtime)
9309 if _err != nil {
9310 return _result, _err
9311 }
9312 _result = _body
9313 return _result, _err
9314 }
9315
9316 // Summary:
9317 //
9318 // 获取公共DNS 威胁统计列表
9319 //
9320 // @param request - DescribePdnsThreatStatisticsRequest
9321 //
9322 // @param runtime - runtime options for this request RuntimeOptions
9323 //
9324 // @return DescribePdnsThreatStatisticsResponse
9325 func DescribePdnsThreatStatisticsWithOptions(client *Client, request *DescribePdnsThreatStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatStatisticsResponse, _err error) {
9326 if dara.BoolValue(client.EnableValidate) == true {
9327 _err = request.Validate()
9328 if _err != nil {
9329 return _result, _err
9330 }
9331 }
9332 query := map[string]interface{}{}
9333 if !dara.IsNil(request.Direction) {
9334 query["Direction"] = request.Direction
9335 }
9336
9337 if !dara.IsNil(request.DomainName) {
9338 query["DomainName"] = request.DomainName
9339 }
9340
9341 if !dara.IsNil(request.EndDate) {
9342 query["EndDate"] = request.EndDate
9343 }
9344
9345 if !dara.IsNil(request.Lang) {
9346 query["Lang"] = request.Lang
9347 }
9348
9349 if !dara.IsNil(request.OrderBy) {
9350 query["OrderBy"] = request.OrderBy
9351 }
9352
9353 if !dara.IsNil(request.PageNumber) {
9354 query["PageNumber"] = request.PageNumber
9355 }
9356
9357 if !dara.IsNil(request.PageSize) {
9358 query["PageSize"] = request.PageSize
9359 }
9360
9361 if !dara.IsNil(request.StartDate) {
9362 query["StartDate"] = request.StartDate
9363 }
9364
9365 if !dara.IsNil(request.SubDomain) {
9366 query["SubDomain"] = request.SubDomain
9367 }
9368
9369 if !dara.IsNil(request.ThreatLevel) {
9370 query["ThreatLevel"] = request.ThreatLevel
9371 }
9372
9373 if !dara.IsNil(request.ThreatSourceIp) {
9374 query["ThreatSourceIp"] = request.ThreatSourceIp
9375 }
9376
9377 if !dara.IsNil(request.ThreatType) {
9378 query["ThreatType"] = request.ThreatType
9379 }
9380
9381 if !dara.IsNil(request.Type) {
9382 query["Type"] = request.Type
9383 }
9384
9385 req := &openapiutil.OpenApiRequest{
9386 Query: openapiutil.Query(query),
9387 }
9388 params := &openapiutil.Params{
9389 Action: dara.String("DescribePdnsThreatStatistics"),
9390 Version: dara.String("2015-01-09"),
9391 Protocol: dara.String("HTTPS"),
9392 Pathname: dara.String("/"),
9393 Method: dara.String("POST"),
9394 AuthType: dara.String("AK"),
9395 Style: dara.String("RPC"),
9396 ReqBodyType: dara.String("formData"),
9397 BodyType: dara.String("json"),
9398 }
9399 _result = &DescribePdnsThreatStatisticsResponse{}
9400 _body, _err := client.CallApi(params, req, runtime)
9401 if _err != nil {
9402 return _result, _err
9403 }
9404 _err = dara.Convert(_body, &_result)
9405 return _result, _err
9406 }
9407
9408 // Summary:
9409 //
9410 // 获取公共DNS 威胁统计列表
9411 //
9412 // @param request - DescribePdnsThreatStatisticsRequest
9413 //
9414 // @return DescribePdnsThreatStatisticsResponse
9415 func DescribePdnsThreatStatistics(client *Client, request *DescribePdnsThreatStatisticsRequest) (_result *DescribePdnsThreatStatisticsResponse, _err error) {
9416 runtime := &dara.RuntimeOptions{}
9417 _result = &DescribePdnsThreatStatisticsResponse{}
9418 _body, _err := DescribePdnsThreatStatisticsWithOptions(client,request, runtime)
9419 if _err != nil {
9420 return _result, _err
9421 }
9422 _result = _body
9423 return _result, _err
9424 }
9425
9426 // Summary:
9427 //
9428 // 获取公共DNS Udp IP段列表
9429 //
9430 // @param request - DescribePdnsUdpIpSegmentsRequest
9431 //
9432 // @param runtime - runtime options for this request RuntimeOptions
9433 //
9434 // @return DescribePdnsUdpIpSegmentsResponse
9435 func DescribePdnsUdpIpSegmentsWithOptions(client *Client, request *DescribePdnsUdpIpSegmentsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsUdpIpSegmentsResponse, _err error) {
9436 if dara.BoolValue(client.EnableValidate) == true {
9437 _err = request.Validate()
9438 if _err != nil {
9439 return _result, _err
9440 }
9441 }
9442 query := map[string]interface{}{}
9443 if !dara.IsNil(request.Lang) {
9444 query["Lang"] = request.Lang
9445 }
9446
9447 if !dara.IsNil(request.PageNumber) {
9448 query["PageNumber"] = request.PageNumber
9449 }
9450
9451 if !dara.IsNil(request.PageSize) {
9452 query["PageSize"] = request.PageSize
9453 }
9454
9455 req := &openapiutil.OpenApiRequest{
9456 Query: openapiutil.Query(query),
9457 }
9458 params := &openapiutil.Params{
9459 Action: dara.String("DescribePdnsUdpIpSegments"),
9460 Version: dara.String("2015-01-09"),
9461 Protocol: dara.String("HTTPS"),
9462 Pathname: dara.String("/"),
9463 Method: dara.String("POST"),
9464 AuthType: dara.String("AK"),
9465 Style: dara.String("RPC"),
9466 ReqBodyType: dara.String("formData"),
9467 BodyType: dara.String("json"),
9468 }
9469 _result = &DescribePdnsUdpIpSegmentsResponse{}
9470 _body, _err := client.CallApi(params, req, runtime)
9471 if _err != nil {
9472 return _result, _err
9473 }
9474 _err = dara.Convert(_body, &_result)
9475 return _result, _err
9476 }
9477
9478 // Summary:
9479 //
9480 // 获取公共DNS Udp IP段列表
9481 //
9482 // @param request - DescribePdnsUdpIpSegmentsRequest
9483 //
9484 // @return DescribePdnsUdpIpSegmentsResponse
9485 func DescribePdnsUdpIpSegments(client *Client, request *DescribePdnsUdpIpSegmentsRequest) (_result *DescribePdnsUdpIpSegmentsResponse, _err error) {
9486 runtime := &dara.RuntimeOptions{}
9487 _result = &DescribePdnsUdpIpSegmentsResponse{}
9488 _body, _err := DescribePdnsUdpIpSegmentsWithOptions(client,request, runtime)
9489 if _err != nil {
9490 return _result, _err
9491 }
9492 _result = _body
9493 return _result, _err
9494 }
9495
9496 // Summary:
9497 //
9498 // Queries the information about users in Alibaba Cloud Public DNS.
9499 //
9500 // @param request - DescribePdnsUserInfoRequest
9501 //
9502 // @param runtime - runtime options for this request RuntimeOptions
9503 //
9504 // @return DescribePdnsUserInfoResponse
9505 func DescribePdnsUserInfoWithOptions(client *Client, request *DescribePdnsUserInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsUserInfoResponse, _err error) {
9506 if dara.BoolValue(client.EnableValidate) == true {
9507 _err = request.Validate()
9508 if _err != nil {
9509 return _result, _err
9510 }
9511 }
9512 query := map[string]interface{}{}
9513 if !dara.IsNil(request.Lang) {
9514 query["Lang"] = request.Lang
9515 }
9516
9517 req := &openapiutil.OpenApiRequest{
9518 Query: openapiutil.Query(query),
9519 }
9520 params := &openapiutil.Params{
9521 Action: dara.String("DescribePdnsUserInfo"),
9522 Version: dara.String("2015-01-09"),
9523 Protocol: dara.String("HTTPS"),
9524 Pathname: dara.String("/"),
9525 Method: dara.String("POST"),
9526 AuthType: dara.String("AK"),
9527 Style: dara.String("RPC"),
9528 ReqBodyType: dara.String("formData"),
9529 BodyType: dara.String("json"),
9530 }
9531 _result = &DescribePdnsUserInfoResponse{}
9532 _body, _err := client.CallApi(params, req, runtime)
9533 if _err != nil {
9534 return _result, _err
9535 }
9536 _err = dara.Convert(_body, &_result)
9537 return _result, _err
9538 }
9539
9540 // Summary:
9541 //
9542 // Queries the information about users in Alibaba Cloud Public DNS.
9543 //
9544 // @param request - DescribePdnsUserInfoRequest
9545 //
9546 // @return DescribePdnsUserInfoResponse
9547 func DescribePdnsUserInfo(client *Client, request *DescribePdnsUserInfoRequest) (_result *DescribePdnsUserInfoResponse, _err error) {
9548 runtime := &dara.RuntimeOptions{}
9549 _result = &DescribePdnsUserInfoResponse{}
9550 _body, _err := DescribePdnsUserInfoWithOptions(client,request, runtime)
9551 if _err != nil {
9552 return _result, _err
9553 }
9554 _result = _body
9555 return _result, _err
9556 }
9557
9558 // Summary:
9559 //
9560 // Queries the operation logs of a domain name based on the specified parameters.
9561 //
9562 // @param request - DescribeRecordLogsRequest
9563 //
9564 // @param runtime - runtime options for this request RuntimeOptions
9565 //
9566 // @return DescribeRecordLogsResponse
9567 func DescribeRecordLogsWithOptions(client *Client, request *DescribeRecordLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordLogsResponse, _err error) {
9568 if dara.BoolValue(client.EnableValidate) == true {
9569 _err = request.Validate()
9570 if _err != nil {
9571 return _result, _err
9572 }
9573 }
9574 query := map[string]interface{}{}
9575 if !dara.IsNil(request.DomainName) {
9576 query["DomainName"] = request.DomainName
9577 }
9578
9579 if !dara.IsNil(request.KeyWord) {
9580 query["KeyWord"] = request.KeyWord
9581 }
9582
9583 if !dara.IsNil(request.Lang) {
9584 query["Lang"] = request.Lang
9585 }
9586
9587 if !dara.IsNil(request.PageNumber) {
9588 query["PageNumber"] = request.PageNumber
9589 }
9590
9591 if !dara.IsNil(request.PageSize) {
9592 query["PageSize"] = request.PageSize
9593 }
9594
9595 if !dara.IsNil(request.StartDate) {
9596 query["StartDate"] = request.StartDate
9597 }
9598
9599 if !dara.IsNil(request.UserClientIp) {
9600 query["UserClientIp"] = request.UserClientIp
9601 }
9602
9603 if !dara.IsNil(request.EndDate) {
9604 query["endDate"] = request.EndDate
9605 }
9606
9607 req := &openapiutil.OpenApiRequest{
9608 Query: openapiutil.Query(query),
9609 }
9610 params := &openapiutil.Params{
9611 Action: dara.String("DescribeRecordLogs"),
9612 Version: dara.String("2015-01-09"),
9613 Protocol: dara.String("HTTPS"),
9614 Pathname: dara.String("/"),
9615 Method: dara.String("POST"),
9616 AuthType: dara.String("AK"),
9617 Style: dara.String("RPC"),
9618 ReqBodyType: dara.String("formData"),
9619 BodyType: dara.String("json"),
9620 }
9621 _result = &DescribeRecordLogsResponse{}
9622 _body, _err := client.CallApi(params, req, runtime)
9623 if _err != nil {
9624 return _result, _err
9625 }
9626 _err = dara.Convert(_body, &_result)
9627 return _result, _err
9628 }
9629
9630 // Summary:
9631 //
9632 // Queries the operation logs of a domain name based on the specified parameters.
9633 //
9634 // @param request - DescribeRecordLogsRequest
9635 //
9636 // @return DescribeRecordLogsResponse
9637 func DescribeRecordLogs(client *Client, request *DescribeRecordLogsRequest) (_result *DescribeRecordLogsResponse, _err error) {
9638 runtime := &dara.RuntimeOptions{}
9639 _result = &DescribeRecordLogsResponse{}
9640 _body, _err := DescribeRecordLogsWithOptions(client,request, runtime)
9641 if _err != nil {
9642 return _result, _err
9643 }
9644 _result = _body
9645 return _result, _err
9646 }
9647
9648 // Summary:
9649 //
9650 // Queries the number of resolution requests for all subdomain names of a specified domain name.
9651 //
9652 // @param request - DescribeRecordResolveStatisticsSummaryRequest
9653 //
9654 // @param runtime - runtime options for this request RuntimeOptions
9655 //
9656 // @return DescribeRecordResolveStatisticsSummaryResponse
9657 func DescribeRecordResolveStatisticsSummaryWithOptions(client *Client, request *DescribeRecordResolveStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordResolveStatisticsSummaryResponse, _err error) {
9658 if dara.BoolValue(client.EnableValidate) == true {
9659 _err = request.Validate()
9660 if _err != nil {
9661 return _result, _err
9662 }
9663 }
9664 query := map[string]interface{}{}
9665 if !dara.IsNil(request.Direction) {
9666 query["Direction"] = request.Direction
9667 }
9668
9669 if !dara.IsNil(request.DomainName) {
9670 query["DomainName"] = request.DomainName
9671 }
9672
9673 if !dara.IsNil(request.DomainType) {
9674 query["DomainType"] = request.DomainType
9675 }
9676
9677 if !dara.IsNil(request.EndDate) {
9678 query["EndDate"] = request.EndDate
9679 }
9680
9681 if !dara.IsNil(request.Keyword) {
9682 query["Keyword"] = request.Keyword
9683 }
9684
9685 if !dara.IsNil(request.Lang) {
9686 query["Lang"] = request.Lang
9687 }
9688
9689 if !dara.IsNil(request.PageNumber) {
9690 query["PageNumber"] = request.PageNumber
9691 }
9692
9693 if !dara.IsNil(request.PageSize) {
9694 query["PageSize"] = request.PageSize
9695 }
9696
9697 if !dara.IsNil(request.SearchMode) {
9698 query["SearchMode"] = request.SearchMode
9699 }
9700
9701 if !dara.IsNil(request.StartDate) {
9702 query["StartDate"] = request.StartDate
9703 }
9704
9705 if !dara.IsNil(request.Threshold) {
9706 query["Threshold"] = request.Threshold
9707 }
9708
9709 req := &openapiutil.OpenApiRequest{
9710 Query: openapiutil.Query(query),
9711 }
9712 params := &openapiutil.Params{
9713 Action: dara.String("DescribeRecordResolveStatisticsSummary"),
9714 Version: dara.String("2015-01-09"),
9715 Protocol: dara.String("HTTPS"),
9716 Pathname: dara.String("/"),
9717 Method: dara.String("POST"),
9718 AuthType: dara.String("AK"),
9719 Style: dara.String("RPC"),
9720 ReqBodyType: dara.String("formData"),
9721 BodyType: dara.String("json"),
9722 }
9723 _result = &DescribeRecordResolveStatisticsSummaryResponse{}
9724 _body, _err := client.CallApi(params, req, runtime)
9725 if _err != nil {
9726 return _result, _err
9727 }
9728 _err = dara.Convert(_body, &_result)
9729 return _result, _err
9730 }
9731
9732 // Summary:
9733 //
9734 // Queries the number of resolution requests for all subdomain names of a specified domain name.
9735 //
9736 // @param request - DescribeRecordResolveStatisticsSummaryRequest
9737 //
9738 // @return DescribeRecordResolveStatisticsSummaryResponse
9739 func DescribeRecordResolveStatisticsSummary(client *Client, request *DescribeRecordResolveStatisticsSummaryRequest) (_result *DescribeRecordResolveStatisticsSummaryResponse, _err error) {
9740 runtime := &dara.RuntimeOptions{}
9741 _result = &DescribeRecordResolveStatisticsSummaryResponse{}
9742 _body, _err := DescribeRecordResolveStatisticsSummaryWithOptions(client,request, runtime)
9743 if _err != nil {
9744 return _result, _err
9745 }
9746 _result = _body
9747 return _result, _err
9748 }
9749
9750 // Summary:
9751 //
9752 // Queries the real-time statistics on the Domain Name System (DNS) requests for a subdomain name.
9753 //
9754 // Description:
9755 //
9756 // Real-time data is collected per hour.
9757 //
9758 // @param request - DescribeRecordStatisticsRequest
9759 //
9760 // @param runtime - runtime options for this request RuntimeOptions
9761 //
9762 // @return DescribeRecordStatisticsResponse
9763 func DescribeRecordStatisticsWithOptions(client *Client, request *DescribeRecordStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordStatisticsResponse, _err error) {
9764 if dara.BoolValue(client.EnableValidate) == true {
9765 _err = request.Validate()
9766 if _err != nil {
9767 return _result, _err
9768 }
9769 }
9770 query := map[string]interface{}{}
9771 if !dara.IsNil(request.DomainName) {
9772 query["DomainName"] = request.DomainName
9773 }
9774
9775 if !dara.IsNil(request.DomainType) {
9776 query["DomainType"] = request.DomainType
9777 }
9778
9779 if !dara.IsNil(request.EndDate) {
9780 query["EndDate"] = request.EndDate
9781 }
9782
9783 if !dara.IsNil(request.Lang) {
9784 query["Lang"] = request.Lang
9785 }
9786
9787 if !dara.IsNil(request.Rr) {
9788 query["Rr"] = request.Rr
9789 }
9790
9791 if !dara.IsNil(request.StartDate) {
9792 query["StartDate"] = request.StartDate
9793 }
9794
9795 req := &openapiutil.OpenApiRequest{
9796 Query: openapiutil.Query(query),
9797 }
9798 params := &openapiutil.Params{
9799 Action: dara.String("DescribeRecordStatistics"),
9800 Version: dara.String("2015-01-09"),
9801 Protocol: dara.String("HTTPS"),
9802 Pathname: dara.String("/"),
9803 Method: dara.String("POST"),
9804 AuthType: dara.String("AK"),
9805 Style: dara.String("RPC"),
9806 ReqBodyType: dara.String("formData"),
9807 BodyType: dara.String("json"),
9808 }
9809 _result = &DescribeRecordStatisticsResponse{}
9810 _body, _err := client.CallApi(params, req, runtime)
9811 if _err != nil {
9812 return _result, _err
9813 }
9814 _err = dara.Convert(_body, &_result)
9815 return _result, _err
9816 }
9817
9818 // Summary:
9819 //
9820 // Queries the real-time statistics on the Domain Name System (DNS) requests for a subdomain name.
9821 //
9822 // Description:
9823 //
9824 // Real-time data is collected per hour.
9825 //
9826 // @param request - DescribeRecordStatisticsRequest
9827 //
9828 // @return DescribeRecordStatisticsResponse
9829 func DescribeRecordStatistics(client *Client, request *DescribeRecordStatisticsRequest) (_result *DescribeRecordStatisticsResponse, _err error) {
9830 runtime := &dara.RuntimeOptions{}
9831 _result = &DescribeRecordStatisticsResponse{}
9832 _body, _err := DescribeRecordStatisticsWithOptions(client,request, runtime)
9833 if _err != nil {
9834 return _result, _err
9835 }
9836 _result = _body
9837 return _result, _err
9838 }
9839
9840 // Summary:
9841 //
9842 // Queries the number of Domain Name System (DNS) requests for all subdomain names of a specified domain name.
9843 //
9844 // @param request - DescribeRecordStatisticsSummaryRequest
9845 //
9846 // @param runtime - runtime options for this request RuntimeOptions
9847 //
9848 // @return DescribeRecordStatisticsSummaryResponse
9849 func DescribeRecordStatisticsSummaryWithOptions(client *Client, request *DescribeRecordStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordStatisticsSummaryResponse, _err error) {
9850 if dara.BoolValue(client.EnableValidate) == true {
9851 _err = request.Validate()
9852 if _err != nil {
9853 return _result, _err
9854 }
9855 }
9856 query := map[string]interface{}{}
9857 if !dara.IsNil(request.DomainName) {
9858 query["DomainName"] = request.DomainName
9859 }
9860
9861 if !dara.IsNil(request.DomainType) {
9862 query["DomainType"] = request.DomainType
9863 }
9864
9865 if !dara.IsNil(request.EndDate) {
9866 query["EndDate"] = request.EndDate
9867 }
9868
9869 if !dara.IsNil(request.Keyword) {
9870 query["Keyword"] = request.Keyword
9871 }
9872
9873 if !dara.IsNil(request.Lang) {
9874 query["Lang"] = request.Lang
9875 }
9876
9877 if !dara.IsNil(request.PageNumber) {
9878 query["PageNumber"] = request.PageNumber
9879 }
9880
9881 if !dara.IsNil(request.PageSize) {
9882 query["PageSize"] = request.PageSize
9883 }
9884
9885 if !dara.IsNil(request.SearchMode) {
9886 query["SearchMode"] = request.SearchMode
9887 }
9888
9889 if !dara.IsNil(request.StartDate) {
9890 query["StartDate"] = request.StartDate
9891 }
9892
9893 if !dara.IsNil(request.Threshold) {
9894 query["Threshold"] = request.Threshold
9895 }
9896
9897 req := &openapiutil.OpenApiRequest{
9898 Query: openapiutil.Query(query),
9899 }
9900 params := &openapiutil.Params{
9901 Action: dara.String("DescribeRecordStatisticsSummary"),
9902 Version: dara.String("2015-01-09"),
9903 Protocol: dara.String("HTTPS"),
9904 Pathname: dara.String("/"),
9905 Method: dara.String("POST"),
9906 AuthType: dara.String("AK"),
9907 Style: dara.String("RPC"),
9908 ReqBodyType: dara.String("formData"),
9909 BodyType: dara.String("json"),
9910 }
9911 _result = &DescribeRecordStatisticsSummaryResponse{}
9912 _body, _err := client.CallApi(params, req, runtime)
9913 if _err != nil {
9914 return _result, _err
9915 }
9916 _err = dara.Convert(_body, &_result)
9917 return _result, _err
9918 }
9919
9920 // Summary:
9921 //
9922 // Queries the number of Domain Name System (DNS) requests for all subdomain names of a specified domain name.
9923 //
9924 // @param request - DescribeRecordStatisticsSummaryRequest
9925 //
9926 // @return DescribeRecordStatisticsSummaryResponse
9927 func DescribeRecordStatisticsSummary(client *Client, request *DescribeRecordStatisticsSummaryRequest) (_result *DescribeRecordStatisticsSummaryResponse, _err error) {
9928 runtime := &dara.RuntimeOptions{}
9929 _result = &DescribeRecordStatisticsSummaryResponse{}
9930 _body, _err := DescribeRecordStatisticsSummaryWithOptions(client,request, runtime)
9931 if _err != nil {
9932 return _result, _err
9933 }
9934 _result = _body
9935 return _result, _err
9936 }
9937
9938 // Summary:
9939 //
9940 // 查询递归解析内置权威解析记录详情
9941 //
9942 // @param request - DescribeRecursionRecordRequest
9943 //
9944 // @param runtime - runtime options for this request RuntimeOptions
9945 //
9946 // @return DescribeRecursionRecordResponse
9947 func DescribeRecursionRecordWithOptions(client *Client, request *DescribeRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecursionRecordResponse, _err error) {
9948 if dara.BoolValue(client.EnableValidate) == true {
9949 _err = request.Validate()
9950 if _err != nil {
9951 return _result, _err
9952 }
9953 }
9954 query := map[string]interface{}{}
9955 if !dara.IsNil(request.RecordId) {
9956 query["RecordId"] = request.RecordId
9957 }
9958
9959 req := &openapiutil.OpenApiRequest{
9960 Query: openapiutil.Query(query),
9961 }
9962 params := &openapiutil.Params{
9963 Action: dara.String("DescribeRecursionRecord"),
9964 Version: dara.String("2015-01-09"),
9965 Protocol: dara.String("HTTPS"),
9966 Pathname: dara.String("/"),
9967 Method: dara.String("POST"),
9968 AuthType: dara.String("AK"),
9969 Style: dara.String("RPC"),
9970 ReqBodyType: dara.String("formData"),
9971 BodyType: dara.String("json"),
9972 }
9973 _result = &DescribeRecursionRecordResponse{}
9974 _body, _err := client.CallApi(params, req, runtime)
9975 if _err != nil {
9976 return _result, _err
9977 }
9978 _err = dara.Convert(_body, &_result)
9979 return _result, _err
9980 }
9981
9982 // Summary:
9983 //
9984 // 查询递归解析内置权威解析记录详情
9985 //
9986 // @param request - DescribeRecursionRecordRequest
9987 //
9988 // @return DescribeRecursionRecordResponse
9989 func DescribeRecursionRecord(client *Client, request *DescribeRecursionRecordRequest) (_result *DescribeRecursionRecordResponse, _err error) {
9990 runtime := &dara.RuntimeOptions{}
9991 _result = &DescribeRecursionRecordResponse{}
9992 _body, _err := DescribeRecursionRecordWithOptions(client,request, runtime)
9993 if _err != nil {
9994 return _result, _err
9995 }
9996 _result = _body
9997 return _result, _err
9998 }
9999
10000 // Summary:
10001 //
10002 // 查询递归解析内置权威域名zone详情
10003 //
10004 // @param request - DescribeRecursionZoneRequest
10005 //
10006 // @param runtime - runtime options for this request RuntimeOptions
10007 //
10008 // @return DescribeRecursionZoneResponse
10009 func DescribeRecursionZoneWithOptions(client *Client, request *DescribeRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecursionZoneResponse, _err error) {
10010 if dara.BoolValue(client.EnableValidate) == true {
10011 _err = request.Validate()
10012 if _err != nil {
10013 return _result, _err
10014 }
10015 }
10016 query := map[string]interface{}{}
10017 if !dara.IsNil(request.ZoneId) {
10018 query["ZoneId"] = request.ZoneId
10019 }
10020
10021 req := &openapiutil.OpenApiRequest{
10022 Query: openapiutil.Query(query),
10023 }
10024 params := &openapiutil.Params{
10025 Action: dara.String("DescribeRecursionZone"),
10026 Version: dara.String("2015-01-09"),
10027 Protocol: dara.String("HTTPS"),
10028 Pathname: dara.String("/"),
10029 Method: dara.String("POST"),
10030 AuthType: dara.String("AK"),
10031 Style: dara.String("RPC"),
10032 ReqBodyType: dara.String("formData"),
10033 BodyType: dara.String("json"),
10034 }
10035 _result = &DescribeRecursionZoneResponse{}
10036 _body, _err := client.CallApi(params, req, runtime)
10037 if _err != nil {
10038 return _result, _err
10039 }
10040 _err = dara.Convert(_body, &_result)
10041 return _result, _err
10042 }
10043
10044 // Summary:
10045 //
10046 // 查询递归解析内置权威域名zone详情
10047 //
10048 // @param request - DescribeRecursionZoneRequest
10049 //
10050 // @return DescribeRecursionZoneResponse
10051 func DescribeRecursionZone(client *Client, request *DescribeRecursionZoneRequest) (_result *DescribeRecursionZoneResponse, _err error) {
10052 runtime := &dara.RuntimeOptions{}
10053 _result = &DescribeRecursionZoneResponse{}
10054 _body, _err := DescribeRecursionZoneWithOptions(client,request, runtime)
10055 if _err != nil {
10056 return _result, _err
10057 }
10058 _result = _body
10059 return _result, _err
10060 }
10061
10062 // Summary:
10063 //
10064 // Queries all Domain Name System (DNS) records of a subdomain name based on the specified parameters.
10065 //
10066 // @param request - DescribeSubDomainRecordsRequest
10067 //
10068 // @param runtime - runtime options for this request RuntimeOptions
10069 //
10070 // @return DescribeSubDomainRecordsResponse
10071 func DescribeSubDomainRecordsWithOptions(client *Client, request *DescribeSubDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DescribeSubDomainRecordsResponse, _err error) {
10072 if dara.BoolValue(client.EnableValidate) == true {
10073 _err = request.Validate()
10074 if _err != nil {
10075 return _result, _err
10076 }
10077 }
10078 query := map[string]interface{}{}
10079 if !dara.IsNil(request.DomainName) {
10080 query["DomainName"] = request.DomainName
10081 }
10082
10083 if !dara.IsNil(request.Lang) {
10084 query["Lang"] = request.Lang
10085 }
10086
10087 if !dara.IsNil(request.Line) {
10088 query["Line"] = request.Line
10089 }
10090
10091 if !dara.IsNil(request.PageNumber) {
10092 query["PageNumber"] = request.PageNumber
10093 }
10094
10095 if !dara.IsNil(request.PageSize) {
10096 query["PageSize"] = request.PageSize
10097 }
10098
10099 if !dara.IsNil(request.SubDomain) {
10100 query["SubDomain"] = request.SubDomain
10101 }
10102
10103 if !dara.IsNil(request.Type) {
10104 query["Type"] = request.Type
10105 }
10106
10107 if !dara.IsNil(request.UserClientIp) {
10108 query["UserClientIp"] = request.UserClientIp
10109 }
10110
10111 req := &openapiutil.OpenApiRequest{
10112 Query: openapiutil.Query(query),
10113 }
10114 params := &openapiutil.Params{
10115 Action: dara.String("DescribeSubDomainRecords"),
10116 Version: dara.String("2015-01-09"),
10117 Protocol: dara.String("HTTPS"),
10118 Pathname: dara.String("/"),
10119 Method: dara.String("POST"),
10120 AuthType: dara.String("AK"),
10121 Style: dara.String("RPC"),
10122 ReqBodyType: dara.String("formData"),
10123 BodyType: dara.String("json"),
10124 }
10125 _result = &DescribeSubDomainRecordsResponse{}
10126 _body, _err := client.CallApi(params, req, runtime)
10127 if _err != nil {
10128 return _result, _err
10129 }
10130 _err = dara.Convert(_body, &_result)
10131 return _result, _err
10132 }
10133
10134 // Summary:
10135 //
10136 // Queries all Domain Name System (DNS) records of a subdomain name based on the specified parameters.
10137 //
10138 // @param request - DescribeSubDomainRecordsRequest
10139 //
10140 // @return DescribeSubDomainRecordsResponse
10141 func DescribeSubDomainRecords(client *Client, request *DescribeSubDomainRecordsRequest) (_result *DescribeSubDomainRecordsResponse, _err error) {
10142 runtime := &dara.RuntimeOptions{}
10143 _result = &DescribeSubDomainRecordsResponse{}
10144 _body, _err := DescribeSubDomainRecordsWithOptions(client,request, runtime)
10145 if _err != nil {
10146 return _result, _err
10147 }
10148 _result = _body
10149 return _result, _err
10150 }
10151
10152 // Summary:
10153 //
10154 // 查询支持的所有线路
10155 //
10156 // @param request - DescribeSupportLinesRequest
10157 //
10158 // @param runtime - runtime options for this request RuntimeOptions
10159 //
10160 // @return DescribeSupportLinesResponse
10161 func DescribeSupportLinesWithOptions(client *Client, request *DescribeSupportLinesRequest, runtime *dara.RuntimeOptions) (_result *DescribeSupportLinesResponse, _err error) {
10162 if dara.BoolValue(client.EnableValidate) == true {
10163 _err = request.Validate()
10164 if _err != nil {
10165 return _result, _err
10166 }
10167 }
10168 query := map[string]interface{}{}
10169 if !dara.IsNil(request.DomainName) {
10170 query["DomainName"] = request.DomainName
10171 }
10172
10173 if !dara.IsNil(request.Lang) {
10174 query["Lang"] = request.Lang
10175 }
10176
10177 if !dara.IsNil(request.UserClientIp) {
10178 query["UserClientIp"] = request.UserClientIp
10179 }
10180
10181 req := &openapiutil.OpenApiRequest{
10182 Query: openapiutil.Query(query),
10183 }
10184 params := &openapiutil.Params{
10185 Action: dara.String("DescribeSupportLines"),
10186 Version: dara.String("2015-01-09"),
10187 Protocol: dara.String("HTTPS"),
10188 Pathname: dara.String("/"),
10189 Method: dara.String("POST"),
10190 AuthType: dara.String("AK"),
10191 Style: dara.String("RPC"),
10192 ReqBodyType: dara.String("formData"),
10193 BodyType: dara.String("json"),
10194 }
10195 _result = &DescribeSupportLinesResponse{}
10196 _body, _err := client.CallApi(params, req, runtime)
10197 if _err != nil {
10198 return _result, _err
10199 }
10200 _err = dara.Convert(_body, &_result)
10201 return _result, _err
10202 }
10203
10204 // Summary:
10205 //
10206 // 查询支持的所有线路
10207 //
10208 // @param request - DescribeSupportLinesRequest
10209 //
10210 // @return DescribeSupportLinesResponse
10211 func DescribeSupportLines(client *Client, request *DescribeSupportLinesRequest) (_result *DescribeSupportLinesResponse, _err error) {
10212 runtime := &dara.RuntimeOptions{}
10213 _result = &DescribeSupportLinesResponse{}
10214 _body, _err := DescribeSupportLinesWithOptions(client,request, runtime)
10215 if _err != nil {
10216 return _result, _err
10217 }
10218 _result = _body
10219 return _result, _err
10220 }
10221
10222 // Summary:
10223 //
10224 // Queries existing tags.
10225 //
10226 // @param request - DescribeTagsRequest
10227 //
10228 // @param runtime - runtime options for this request RuntimeOptions
10229 //
10230 // @return DescribeTagsResponse
10231 func DescribeTagsWithOptions(client *Client, request *DescribeTagsRequest, runtime *dara.RuntimeOptions) (_result *DescribeTagsResponse, _err error) {
10232 if dara.BoolValue(client.EnableValidate) == true {
10233 _err = request.Validate()
10234 if _err != nil {
10235 return _result, _err
10236 }
10237 }
10238 query := map[string]interface{}{}
10239 if !dara.IsNil(request.Lang) {
10240 query["Lang"] = request.Lang
10241 }
10242
10243 if !dara.IsNil(request.PageNumber) {
10244 query["PageNumber"] = request.PageNumber
10245 }
10246
10247 if !dara.IsNil(request.PageSize) {
10248 query["PageSize"] = request.PageSize
10249 }
10250
10251 if !dara.IsNil(request.ResourceType) {
10252 query["ResourceType"] = request.ResourceType
10253 }
10254
10255 req := &openapiutil.OpenApiRequest{
10256 Query: openapiutil.Query(query),
10257 }
10258 params := &openapiutil.Params{
10259 Action: dara.String("DescribeTags"),
10260 Version: dara.String("2015-01-09"),
10261 Protocol: dara.String("HTTPS"),
10262 Pathname: dara.String("/"),
10263 Method: dara.String("POST"),
10264 AuthType: dara.String("AK"),
10265 Style: dara.String("RPC"),
10266 ReqBodyType: dara.String("formData"),
10267 BodyType: dara.String("json"),
10268 }
10269 _result = &DescribeTagsResponse{}
10270 _body, _err := client.CallApi(params, req, runtime)
10271 if _err != nil {
10272 return _result, _err
10273 }
10274 _err = dara.Convert(_body, &_result)
10275 return _result, _err
10276 }
10277
10278 // Summary:
10279 //
10280 // Queries existing tags.
10281 //
10282 // @param request - DescribeTagsRequest
10283 //
10284 // @return DescribeTagsResponse
10285 func DescribeTags(client *Client, request *DescribeTagsRequest) (_result *DescribeTagsResponse, _err error) {
10286 runtime := &dara.RuntimeOptions{}
10287 _result = &DescribeTagsResponse{}
10288 _body, _err := DescribeTagsWithOptions(client,request, runtime)
10289 if _err != nil {
10290 return _result, _err
10291 }
10292 _result = _body
10293 return _result, _err
10294 }
10295
10296 // Summary:
10297 //
10298 // Queries the domain names that were transferred between the current account and another account based on the specified parameters.
10299 //
10300 // @param request - DescribeTransferDomainsRequest
10301 //
10302 // @param runtime - runtime options for this request RuntimeOptions
10303 //
10304 // @return DescribeTransferDomainsResponse
10305 func DescribeTransferDomainsWithOptions(client *Client, request *DescribeTransferDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeTransferDomainsResponse, _err error) {
10306 if dara.BoolValue(client.EnableValidate) == true {
10307 _err = request.Validate()
10308 if _err != nil {
10309 return _result, _err
10310 }
10311 }
10312 query := map[string]interface{}{}
10313 if !dara.IsNil(request.DomainName) {
10314 query["DomainName"] = request.DomainName
10315 }
10316
10317 if !dara.IsNil(request.FromUserId) {
10318 query["FromUserId"] = request.FromUserId
10319 }
10320
10321 if !dara.IsNil(request.Lang) {
10322 query["Lang"] = request.Lang
10323 }
10324
10325 if !dara.IsNil(request.PageNumber) {
10326 query["PageNumber"] = request.PageNumber
10327 }
10328
10329 if !dara.IsNil(request.PageSize) {
10330 query["PageSize"] = request.PageSize
10331 }
10332
10333 if !dara.IsNil(request.TargetUserId) {
10334 query["TargetUserId"] = request.TargetUserId
10335 }
10336
10337 if !dara.IsNil(request.TransferType) {
10338 query["TransferType"] = request.TransferType
10339 }
10340
10341 req := &openapiutil.OpenApiRequest{
10342 Query: openapiutil.Query(query),
10343 }
10344 params := &openapiutil.Params{
10345 Action: dara.String("DescribeTransferDomains"),
10346 Version: dara.String("2015-01-09"),
10347 Protocol: dara.String("HTTPS"),
10348 Pathname: dara.String("/"),
10349 Method: dara.String("POST"),
10350 AuthType: dara.String("AK"),
10351 Style: dara.String("RPC"),
10352 ReqBodyType: dara.String("formData"),
10353 BodyType: dara.String("json"),
10354 }
10355 _result = &DescribeTransferDomainsResponse{}
10356 _body, _err := client.CallApi(params, req, runtime)
10357 if _err != nil {
10358 return _result, _err
10359 }
10360 _err = dara.Convert(_body, &_result)
10361 return _result, _err
10362 }
10363
10364 // Summary:
10365 //
10366 // Queries the domain names that were transferred between the current account and another account based on the specified parameters.
10367 //
10368 // @param request - DescribeTransferDomainsRequest
10369 //
10370 // @return DescribeTransferDomainsResponse
10371 func DescribeTransferDomains(client *Client, request *DescribeTransferDomainsRequest) (_result *DescribeTransferDomainsResponse, _err error) {
10372 runtime := &dara.RuntimeOptions{}
10373 _result = &DescribeTransferDomainsResponse{}
10374 _body, _err := DescribeTransferDomainsWithOptions(client,request, runtime)
10375 if _err != nil {
10376 return _result, _err
10377 }
10378 _result = _body
10379 return _result, _err
10380 }
10381
10382 // Summary:
10383 //
10384 // Executes a disaster recovery plan.
10385 //
10386 // @param request - ExecuteGtmRecoveryPlanRequest
10387 //
10388 // @param runtime - runtime options for this request RuntimeOptions
10389 //
10390 // @return ExecuteGtmRecoveryPlanResponse
10391 func ExecuteGtmRecoveryPlanWithOptions(client *Client, request *ExecuteGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *ExecuteGtmRecoveryPlanResponse, _err error) {
10392 if dara.BoolValue(client.EnableValidate) == true {
10393 _err = request.Validate()
10394 if _err != nil {
10395 return _result, _err
10396 }
10397 }
10398 query := map[string]interface{}{}
10399 if !dara.IsNil(request.Lang) {
10400 query["Lang"] = request.Lang
10401 }
10402
10403 if !dara.IsNil(request.RecoveryPlanId) {
10404 query["RecoveryPlanId"] = request.RecoveryPlanId
10405 }
10406
10407 req := &openapiutil.OpenApiRequest{
10408 Query: openapiutil.Query(query),
10409 }
10410 params := &openapiutil.Params{
10411 Action: dara.String("ExecuteGtmRecoveryPlan"),
10412 Version: dara.String("2015-01-09"),
10413 Protocol: dara.String("HTTPS"),
10414 Pathname: dara.String("/"),
10415 Method: dara.String("POST"),
10416 AuthType: dara.String("AK"),
10417 Style: dara.String("RPC"),
10418 ReqBodyType: dara.String("formData"),
10419 BodyType: dara.String("json"),
10420 }
10421 _result = &ExecuteGtmRecoveryPlanResponse{}
10422 _body, _err := client.CallApi(params, req, runtime)
10423 if _err != nil {
10424 return _result, _err
10425 }
10426 _err = dara.Convert(_body, &_result)
10427 return _result, _err
10428 }
10429
10430 // Summary:
10431 //
10432 // Executes a disaster recovery plan.
10433 //
10434 // @param request - ExecuteGtmRecoveryPlanRequest
10435 //
10436 // @return ExecuteGtmRecoveryPlanResponse
10437 func ExecuteGtmRecoveryPlan(client *Client, request *ExecuteGtmRecoveryPlanRequest) (_result *ExecuteGtmRecoveryPlanResponse, _err error) {
10438 runtime := &dara.RuntimeOptions{}
10439 _result = &ExecuteGtmRecoveryPlanResponse{}
10440 _body, _err := ExecuteGtmRecoveryPlanWithOptions(client,request, runtime)
10441 if _err != nil {
10442 return _result, _err
10443 }
10444 _result = _body
10445 return _result, _err
10446 }
10447
10448 // Summary:
10449 //
10450 // Queries a primary domain name based on the specified parameters.
10451 //
10452 // Description:
10453 //
10454 // # For more information about the difference between primary domain names and subdomain names, see
10455 //
10456 // [Subdomain levels](https://www.alibabacloud.com/help/zh/faq-detail/39803.htm). For example, if you enter `www.abc.com`, abc.com is obtained.
10457 //
10458 // @param request - GetMainDomainNameRequest
10459 //
10460 // @param runtime - runtime options for this request RuntimeOptions
10461 //
10462 // @return GetMainDomainNameResponse
10463 func GetMainDomainNameWithOptions(client *Client, request *GetMainDomainNameRequest, runtime *dara.RuntimeOptions) (_result *GetMainDomainNameResponse, _err error) {
10464 if dara.BoolValue(client.EnableValidate) == true {
10465 _err = request.Validate()
10466 if _err != nil {
10467 return _result, _err
10468 }
10469 }
10470 query := map[string]interface{}{}
10471 if !dara.IsNil(request.InputString) {
10472 query["InputString"] = request.InputString
10473 }
10474
10475 if !dara.IsNil(request.Lang) {
10476 query["Lang"] = request.Lang
10477 }
10478
10479 req := &openapiutil.OpenApiRequest{
10480 Query: openapiutil.Query(query),
10481 }
10482 params := &openapiutil.Params{
10483 Action: dara.String("GetMainDomainName"),
10484 Version: dara.String("2015-01-09"),
10485 Protocol: dara.String("HTTPS"),
10486 Pathname: dara.String("/"),
10487 Method: dara.String("POST"),
10488 AuthType: dara.String("AK"),
10489 Style: dara.String("RPC"),
10490 ReqBodyType: dara.String("formData"),
10491 BodyType: dara.String("json"),
10492 }
10493 _result = &GetMainDomainNameResponse{}
10494 _body, _err := client.CallApi(params, req, runtime)
10495 if _err != nil {
10496 return _result, _err
10497 }
10498 _err = dara.Convert(_body, &_result)
10499 return _result, _err
10500 }
10501
10502 // Summary:
10503 //
10504 // Queries a primary domain name based on the specified parameters.
10505 //
10506 // Description:
10507 //
10508 // # For more information about the difference between primary domain names and subdomain names, see
10509 //
10510 // [Subdomain levels](https://www.alibabacloud.com/help/zh/faq-detail/39803.htm). For example, if you enter `www.abc.com`, abc.com is obtained.
10511 //
10512 // @param request - GetMainDomainNameRequest
10513 //
10514 // @return GetMainDomainNameResponse
10515 func GetMainDomainName(client *Client, request *GetMainDomainNameRequest) (_result *GetMainDomainNameResponse, _err error) {
10516 runtime := &dara.RuntimeOptions{}
10517 _result = &GetMainDomainNameResponse{}
10518 _body, _err := GetMainDomainNameWithOptions(client,request, runtime)
10519 if _err != nil {
10520 return _result, _err
10521 }
10522 _result = _body
10523 return _result, _err
10524 }
10525
10526 // Summary:
10527 //
10528 // Generates a text (TXT) record. TXT records are used to retrieve domain names and subdomain names, enable the subdomain name verification feature, and perform batch retrievals.
10529 //
10530 // @param request - GetTxtRecordForVerifyRequest
10531 //
10532 // @param runtime - runtime options for this request RuntimeOptions
10533 //
10534 // @return GetTxtRecordForVerifyResponse
10535 func GetTxtRecordForVerifyWithOptions(client *Client, request *GetTxtRecordForVerifyRequest, runtime *dara.RuntimeOptions) (_result *GetTxtRecordForVerifyResponse, _err error) {
10536 if dara.BoolValue(client.EnableValidate) == true {
10537 _err = request.Validate()
10538 if _err != nil {
10539 return _result, _err
10540 }
10541 }
10542 query := map[string]interface{}{}
10543 if !dara.IsNil(request.DomainName) {
10544 query["DomainName"] = request.DomainName
10545 }
10546
10547 if !dara.IsNil(request.Lang) {
10548 query["Lang"] = request.Lang
10549 }
10550
10551 if !dara.IsNil(request.Type) {
10552 query["Type"] = request.Type
10553 }
10554
10555 req := &openapiutil.OpenApiRequest{
10556 Query: openapiutil.Query(query),
10557 }
10558 params := &openapiutil.Params{
10559 Action: dara.String("GetTxtRecordForVerify"),
10560 Version: dara.String("2015-01-09"),
10561 Protocol: dara.String("HTTPS"),
10562 Pathname: dara.String("/"),
10563 Method: dara.String("POST"),
10564 AuthType: dara.String("AK"),
10565 Style: dara.String("RPC"),
10566 ReqBodyType: dara.String("formData"),
10567 BodyType: dara.String("json"),
10568 }
10569 _result = &GetTxtRecordForVerifyResponse{}
10570 _body, _err := client.CallApi(params, req, runtime)
10571 if _err != nil {
10572 return _result, _err
10573 }
10574 _err = dara.Convert(_body, &_result)
10575 return _result, _err
10576 }
10577
10578 // Summary:
10579 //
10580 // Generates a text (TXT) record. TXT records are used to retrieve domain names and subdomain names, enable the subdomain name verification feature, and perform batch retrievals.
10581 //
10582 // @param request - GetTxtRecordForVerifyRequest
10583 //
10584 // @return GetTxtRecordForVerifyResponse
10585 func GetTxtRecordForVerify(client *Client, request *GetTxtRecordForVerifyRequest) (_result *GetTxtRecordForVerifyResponse, _err error) {
10586 runtime := &dara.RuntimeOptions{}
10587 _result = &GetTxtRecordForVerifyResponse{}
10588 _body, _err := GetTxtRecordForVerifyWithOptions(client,request, runtime)
10589 if _err != nil {
10590 return _result, _err
10591 }
10592 _result = _body
10593 return _result, _err
10594 }
10595
10596 // Summary:
10597 //
10598 // Queries a list of address pools.
10599 //
10600 // @param request - ListCloudGtmAddressPoolsRequest
10601 //
10602 // @param runtime - runtime options for this request RuntimeOptions
10603 //
10604 // @return ListCloudGtmAddressPoolsResponse
10605 func ListCloudGtmAddressPoolsWithOptions(client *Client, request *ListCloudGtmAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAddressPoolsResponse, _err error) {
10606 if dara.BoolValue(client.EnableValidate) == true {
10607 _err = request.Validate()
10608 if _err != nil {
10609 return _result, _err
10610 }
10611 }
10612 query := map[string]interface{}{}
10613 if !dara.IsNil(request.AcceptLanguage) {
10614 query["AcceptLanguage"] = request.AcceptLanguage
10615 }
10616
10617 if !dara.IsNil(request.AddressPoolName) {
10618 query["AddressPoolName"] = request.AddressPoolName
10619 }
10620
10621 if !dara.IsNil(request.AddressPoolType) {
10622 query["AddressPoolType"] = request.AddressPoolType
10623 }
10624
10625 if !dara.IsNil(request.ClientToken) {
10626 query["ClientToken"] = request.ClientToken
10627 }
10628
10629 if !dara.IsNil(request.EnableStatus) {
10630 query["EnableStatus"] = request.EnableStatus
10631 }
10632
10633 if !dara.IsNil(request.PageNumber) {
10634 query["PageNumber"] = request.PageNumber
10635 }
10636
10637 if !dara.IsNil(request.PageSize) {
10638 query["PageSize"] = request.PageSize
10639 }
10640
10641 if !dara.IsNil(request.Remark) {
10642 query["Remark"] = request.Remark
10643 }
10644
10645 req := &openapiutil.OpenApiRequest{
10646 Query: openapiutil.Query(query),
10647 }
10648 params := &openapiutil.Params{
10649 Action: dara.String("ListCloudGtmAddressPools"),
10650 Version: dara.String("2015-01-09"),
10651 Protocol: dara.String("HTTPS"),
10652 Pathname: dara.String("/"),
10653 Method: dara.String("POST"),
10654 AuthType: dara.String("AK"),
10655 Style: dara.String("RPC"),
10656 ReqBodyType: dara.String("formData"),
10657 BodyType: dara.String("json"),
10658 }
10659 _result = &ListCloudGtmAddressPoolsResponse{}
10660 _body, _err := client.CallApi(params, req, runtime)
10661 if _err != nil {
10662 return _result, _err
10663 }
10664 _err = dara.Convert(_body, &_result)
10665 return _result, _err
10666 }
10667
10668 // Summary:
10669 //
10670 // Queries a list of address pools.
10671 //
10672 // @param request - ListCloudGtmAddressPoolsRequest
10673 //
10674 // @return ListCloudGtmAddressPoolsResponse
10675 func ListCloudGtmAddressPools(client *Client, request *ListCloudGtmAddressPoolsRequest) (_result *ListCloudGtmAddressPoolsResponse, _err error) {
10676 runtime := &dara.RuntimeOptions{}
10677 _result = &ListCloudGtmAddressPoolsResponse{}
10678 _body, _err := ListCloudGtmAddressPoolsWithOptions(client,request, runtime)
10679 if _err != nil {
10680 return _result, _err
10681 }
10682 _result = _body
10683 return _result, _err
10684 }
10685
10686 // Summary:
10687 //
10688 // Queries a list of addresses.
10689 //
10690 // @param request - ListCloudGtmAddressesRequest
10691 //
10692 // @param runtime - runtime options for this request RuntimeOptions
10693 //
10694 // @return ListCloudGtmAddressesResponse
10695 func ListCloudGtmAddressesWithOptions(client *Client, request *ListCloudGtmAddressesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAddressesResponse, _err error) {
10696 if dara.BoolValue(client.EnableValidate) == true {
10697 _err = request.Validate()
10698 if _err != nil {
10699 return _result, _err
10700 }
10701 }
10702 query := map[string]interface{}{}
10703 if !dara.IsNil(request.AcceptLanguage) {
10704 query["AcceptLanguage"] = request.AcceptLanguage
10705 }
10706
10707 if !dara.IsNil(request.Address) {
10708 query["Address"] = request.Address
10709 }
10710
10711 if !dara.IsNil(request.AddressId) {
10712 query["AddressId"] = request.AddressId
10713 }
10714
10715 if !dara.IsNil(request.ClientToken) {
10716 query["ClientToken"] = request.ClientToken
10717 }
10718
10719 if !dara.IsNil(request.EnableStatus) {
10720 query["EnableStatus"] = request.EnableStatus
10721 }
10722
10723 if !dara.IsNil(request.HealthStatus) {
10724 query["HealthStatus"] = request.HealthStatus
10725 }
10726
10727 if !dara.IsNil(request.MonitorTemplateId) {
10728 query["MonitorTemplateId"] = request.MonitorTemplateId
10729 }
10730
10731 if !dara.IsNil(request.Name) {
10732 query["Name"] = request.Name
10733 }
10734
10735 if !dara.IsNil(request.PageNumber) {
10736 query["PageNumber"] = request.PageNumber
10737 }
10738
10739 if !dara.IsNil(request.PageSize) {
10740 query["PageSize"] = request.PageSize
10741 }
10742
10743 if !dara.IsNil(request.Type) {
10744 query["Type"] = request.Type
10745 }
10746
10747 req := &openapiutil.OpenApiRequest{
10748 Query: openapiutil.Query(query),
10749 }
10750 params := &openapiutil.Params{
10751 Action: dara.String("ListCloudGtmAddresses"),
10752 Version: dara.String("2015-01-09"),
10753 Protocol: dara.String("HTTPS"),
10754 Pathname: dara.String("/"),
10755 Method: dara.String("POST"),
10756 AuthType: dara.String("AK"),
10757 Style: dara.String("RPC"),
10758 ReqBodyType: dara.String("formData"),
10759 BodyType: dara.String("json"),
10760 }
10761 _result = &ListCloudGtmAddressesResponse{}
10762 _body, _err := client.CallApi(params, req, runtime)
10763 if _err != nil {
10764 return _result, _err
10765 }
10766 _err = dara.Convert(_body, &_result)
10767 return _result, _err
10768 }
10769
10770 // Summary:
10771 //
10772 // Queries a list of addresses.
10773 //
10774 // @param request - ListCloudGtmAddressesRequest
10775 //
10776 // @return ListCloudGtmAddressesResponse
10777 func ListCloudGtmAddresses(client *Client, request *ListCloudGtmAddressesRequest) (_result *ListCloudGtmAddressesResponse, _err error) {
10778 runtime := &dara.RuntimeOptions{}
10779 _result = &ListCloudGtmAddressesResponse{}
10780 _body, _err := ListCloudGtmAddressesWithOptions(client,request, runtime)
10781 if _err != nil {
10782 return _result, _err
10783 }
10784 _result = _body
10785 return _result, _err
10786 }
10787
10788 // @param request - ListCloudGtmAlertLogsRequest
10789 //
10790 // @param runtime - runtime options for this request RuntimeOptions
10791 //
10792 // @return ListCloudGtmAlertLogsResponse
10793 func ListCloudGtmAlertLogsWithOptions(client *Client, request *ListCloudGtmAlertLogsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAlertLogsResponse, _err error) {
10794 if dara.BoolValue(client.EnableValidate) == true {
10795 _err = request.Validate()
10796 if _err != nil {
10797 return _result, _err
10798 }
10799 }
10800 query := map[string]interface{}{}
10801 if !dara.IsNil(request.ActionType) {
10802 query["ActionType"] = request.ActionType
10803 }
10804
10805 if !dara.IsNil(request.EndTimestamp) {
10806 query["EndTimestamp"] = request.EndTimestamp
10807 }
10808
10809 if !dara.IsNil(request.EntityType) {
10810 query["EntityType"] = request.EntityType
10811 }
10812
10813 if !dara.IsNil(request.Keyword) {
10814 query["Keyword"] = request.Keyword
10815 }
10816
10817 if !dara.IsNil(request.Lang) {
10818 query["Lang"] = request.Lang
10819 }
10820
10821 if !dara.IsNil(request.PageNumber) {
10822 query["PageNumber"] = request.PageNumber
10823 }
10824
10825 if !dara.IsNil(request.PageSize) {
10826 query["PageSize"] = request.PageSize
10827 }
10828
10829 if !dara.IsNil(request.StartTimestamp) {
10830 query["StartTimestamp"] = request.StartTimestamp
10831 }
10832
10833 req := &openapiutil.OpenApiRequest{
10834 Query: openapiutil.Query(query),
10835 }
10836 params := &openapiutil.Params{
10837 Action: dara.String("ListCloudGtmAlertLogs"),
10838 Version: dara.String("2015-01-09"),
10839 Protocol: dara.String("HTTPS"),
10840 Pathname: dara.String("/"),
10841 Method: dara.String("POST"),
10842 AuthType: dara.String("AK"),
10843 Style: dara.String("RPC"),
10844 ReqBodyType: dara.String("formData"),
10845 BodyType: dara.String("json"),
10846 }
10847 _result = &ListCloudGtmAlertLogsResponse{}
10848 _body, _err := client.CallApi(params, req, runtime)
10849 if _err != nil {
10850 return _result, _err
10851 }
10852 _err = dara.Convert(_body, &_result)
10853 return _result, _err
10854 }
10855
10856 // @param request - ListCloudGtmAlertLogsRequest
10857 //
10858 // @return ListCloudGtmAlertLogsResponse
10859 func ListCloudGtmAlertLogs(client *Client, request *ListCloudGtmAlertLogsRequest) (_result *ListCloudGtmAlertLogsResponse, _err error) {
10860 runtime := &dara.RuntimeOptions{}
10861 _result = &ListCloudGtmAlertLogsResponse{}
10862 _body, _err := ListCloudGtmAlertLogsWithOptions(client,request, runtime)
10863 if _err != nil {
10864 return _result, _err
10865 }
10866 _result = _body
10867 return _result, _err
10868 }
10869
10870 // @param request - ListCloudGtmAvailableAlertGroupsRequest
10871 //
10872 // @param runtime - runtime options for this request RuntimeOptions
10873 //
10874 // @return ListCloudGtmAvailableAlertGroupsResponse
10875 func ListCloudGtmAvailableAlertGroupsWithOptions(client *Client, request *ListCloudGtmAvailableAlertGroupsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAvailableAlertGroupsResponse, _err error) {
10876 if dara.BoolValue(client.EnableValidate) == true {
10877 _err = request.Validate()
10878 if _err != nil {
10879 return _result, _err
10880 }
10881 }
10882 query := map[string]interface{}{}
10883 if !dara.IsNil(request.AcceptLanguage) {
10884 query["AcceptLanguage"] = request.AcceptLanguage
10885 }
10886
10887 req := &openapiutil.OpenApiRequest{
10888 Query: openapiutil.Query(query),
10889 }
10890 params := &openapiutil.Params{
10891 Action: dara.String("ListCloudGtmAvailableAlertGroups"),
10892 Version: dara.String("2015-01-09"),
10893 Protocol: dara.String("HTTPS"),
10894 Pathname: dara.String("/"),
10895 Method: dara.String("POST"),
10896 AuthType: dara.String("AK"),
10897 Style: dara.String("RPC"),
10898 ReqBodyType: dara.String("formData"),
10899 BodyType: dara.String("json"),
10900 }
10901 _result = &ListCloudGtmAvailableAlertGroupsResponse{}
10902 _body, _err := client.CallApi(params, req, runtime)
10903 if _err != nil {
10904 return _result, _err
10905 }
10906 _err = dara.Convert(_body, &_result)
10907 return _result, _err
10908 }
10909
10910 // @param request - ListCloudGtmAvailableAlertGroupsRequest
10911 //
10912 // @return ListCloudGtmAvailableAlertGroupsResponse
10913 func ListCloudGtmAvailableAlertGroups(client *Client, request *ListCloudGtmAvailableAlertGroupsRequest) (_result *ListCloudGtmAvailableAlertGroupsResponse, _err error) {
10914 runtime := &dara.RuntimeOptions{}
10915 _result = &ListCloudGtmAvailableAlertGroupsResponse{}
10916 _body, _err := ListCloudGtmAvailableAlertGroupsWithOptions(client,request, runtime)
10917 if _err != nil {
10918 return _result, _err
10919 }
10920 _result = _body
10921 return _result, _err
10922 }
10923
10924 // Summary:
10925 //
10926 // Queries the configurations of a Global Traffic Manager (GTM) instance, including the information about access domain names and address pools.
10927 //
10928 // @param request - ListCloudGtmInstanceConfigsRequest
10929 //
10930 // @param runtime - runtime options for this request RuntimeOptions
10931 //
10932 // @return ListCloudGtmInstanceConfigsResponse
10933 func ListCloudGtmInstanceConfigsWithOptions(client *Client, request *ListCloudGtmInstanceConfigsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmInstanceConfigsResponse, _err error) {
10934 if dara.BoolValue(client.EnableValidate) == true {
10935 _err = request.Validate()
10936 if _err != nil {
10937 return _result, _err
10938 }
10939 }
10940 query := map[string]interface{}{}
10941 if !dara.IsNil(request.AcceptLanguage) {
10942 query["AcceptLanguage"] = request.AcceptLanguage
10943 }
10944
10945 if !dara.IsNil(request.ClientToken) {
10946 query["ClientToken"] = request.ClientToken
10947 }
10948
10949 if !dara.IsNil(request.EnableStatus) {
10950 query["EnableStatus"] = request.EnableStatus
10951 }
10952
10953 if !dara.IsNil(request.InstanceId) {
10954 query["InstanceId"] = request.InstanceId
10955 }
10956
10957 if !dara.IsNil(request.PageNumber) {
10958 query["PageNumber"] = request.PageNumber
10959 }
10960
10961 if !dara.IsNil(request.PageSize) {
10962 query["PageSize"] = request.PageSize
10963 }
10964
10965 if !dara.IsNil(request.Remark) {
10966 query["Remark"] = request.Remark
10967 }
10968
10969 if !dara.IsNil(request.ScheduleDomainName) {
10970 query["ScheduleDomainName"] = request.ScheduleDomainName
10971 }
10972
10973 if !dara.IsNil(request.ScheduleZoneName) {
10974 query["ScheduleZoneName"] = request.ScheduleZoneName
10975 }
10976
10977 req := &openapiutil.OpenApiRequest{
10978 Query: openapiutil.Query(query),
10979 }
10980 params := &openapiutil.Params{
10981 Action: dara.String("ListCloudGtmInstanceConfigs"),
10982 Version: dara.String("2015-01-09"),
10983 Protocol: dara.String("HTTPS"),
10984 Pathname: dara.String("/"),
10985 Method: dara.String("POST"),
10986 AuthType: dara.String("AK"),
10987 Style: dara.String("RPC"),
10988 ReqBodyType: dara.String("formData"),
10989 BodyType: dara.String("json"),
10990 }
10991 _result = &ListCloudGtmInstanceConfigsResponse{}
10992 _body, _err := client.CallApi(params, req, runtime)
10993 if _err != nil {
10994 return _result, _err
10995 }
10996 _err = dara.Convert(_body, &_result)
10997 return _result, _err
10998 }
10999
11000 // Summary:
11001 //
11002 // Queries the configurations of a Global Traffic Manager (GTM) instance, including the information about access domain names and address pools.
11003 //
11004 // @param request - ListCloudGtmInstanceConfigsRequest
11005 //
11006 // @return ListCloudGtmInstanceConfigsResponse
11007 func ListCloudGtmInstanceConfigs(client *Client, request *ListCloudGtmInstanceConfigsRequest) (_result *ListCloudGtmInstanceConfigsResponse, _err error) {
11008 runtime := &dara.RuntimeOptions{}
11009 _result = &ListCloudGtmInstanceConfigsResponse{}
11010 _body, _err := ListCloudGtmInstanceConfigsWithOptions(client,request, runtime)
11011 if _err != nil {
11012 return _result, _err
11013 }
11014 _result = _body
11015 return _result, _err
11016 }
11017
11018 // Summary:
11019 //
11020 // Queries a list of Global Traffic Manager (GTM) 3.0 instances.
11021 //
11022 // @param request - ListCloudGtmInstancesRequest
11023 //
11024 // @param runtime - runtime options for this request RuntimeOptions
11025 //
11026 // @return ListCloudGtmInstancesResponse
11027 func ListCloudGtmInstancesWithOptions(client *Client, request *ListCloudGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmInstancesResponse, _err error) {
11028 if dara.BoolValue(client.EnableValidate) == true {
11029 _err = request.Validate()
11030 if _err != nil {
11031 return _result, _err
11032 }
11033 }
11034 query := map[string]interface{}{}
11035 if !dara.IsNil(request.AcceptLanguage) {
11036 query["AcceptLanguage"] = request.AcceptLanguage
11037 }
11038
11039 if !dara.IsNil(request.ChargeType) {
11040 query["ChargeType"] = request.ChargeType
11041 }
11042
11043 if !dara.IsNil(request.ClientToken) {
11044 query["ClientToken"] = request.ClientToken
11045 }
11046
11047 if !dara.IsNil(request.InstanceId) {
11048 query["InstanceId"] = request.InstanceId
11049 }
11050
11051 if !dara.IsNil(request.InstanceName) {
11052 query["InstanceName"] = request.InstanceName
11053 }
11054
11055 if !dara.IsNil(request.PageNumber) {
11056 query["PageNumber"] = request.PageNumber
11057 }
11058
11059 if !dara.IsNil(request.PageSize) {
11060 query["PageSize"] = request.PageSize
11061 }
11062
11063 req := &openapiutil.OpenApiRequest{
11064 Query: openapiutil.Query(query),
11065 }
11066 params := &openapiutil.Params{
11067 Action: dara.String("ListCloudGtmInstances"),
11068 Version: dara.String("2015-01-09"),
11069 Protocol: dara.String("HTTPS"),
11070 Pathname: dara.String("/"),
11071 Method: dara.String("POST"),
11072 AuthType: dara.String("AK"),
11073 Style: dara.String("RPC"),
11074 ReqBodyType: dara.String("formData"),
11075 BodyType: dara.String("json"),
11076 }
11077 _result = &ListCloudGtmInstancesResponse{}
11078 _body, _err := client.CallApi(params, req, runtime)
11079 if _err != nil {
11080 return _result, _err
11081 }
11082 _err = dara.Convert(_body, &_result)
11083 return _result, _err
11084 }
11085
11086 // Summary:
11087 //
11088 // Queries a list of Global Traffic Manager (GTM) 3.0 instances.
11089 //
11090 // @param request - ListCloudGtmInstancesRequest
11091 //
11092 // @return ListCloudGtmInstancesResponse
11093 func ListCloudGtmInstances(client *Client, request *ListCloudGtmInstancesRequest) (_result *ListCloudGtmInstancesResponse, _err error) {
11094 runtime := &dara.RuntimeOptions{}
11095 _result = &ListCloudGtmInstancesResponse{}
11096 _body, _err := ListCloudGtmInstancesWithOptions(client,request, runtime)
11097 if _err != nil {
11098 return _result, _err
11099 }
11100 _result = _body
11101 return _result, _err
11102 }
11103
11104 // Summary:
11105 //
11106 // Queries a list of health check nodes.
11107 //
11108 // @param request - ListCloudGtmMonitorNodesRequest
11109 //
11110 // @param runtime - runtime options for this request RuntimeOptions
11111 //
11112 // @return ListCloudGtmMonitorNodesResponse
11113 func ListCloudGtmMonitorNodesWithOptions(client *Client, request *ListCloudGtmMonitorNodesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmMonitorNodesResponse, _err error) {
11114 if dara.BoolValue(client.EnableValidate) == true {
11115 _err = request.Validate()
11116 if _err != nil {
11117 return _result, _err
11118 }
11119 }
11120 query := map[string]interface{}{}
11121 if !dara.IsNil(request.AcceptLanguage) {
11122 query["AcceptLanguage"] = request.AcceptLanguage
11123 }
11124
11125 req := &openapiutil.OpenApiRequest{
11126 Query: openapiutil.Query(query),
11127 }
11128 params := &openapiutil.Params{
11129 Action: dara.String("ListCloudGtmMonitorNodes"),
11130 Version: dara.String("2015-01-09"),
11131 Protocol: dara.String("HTTPS"),
11132 Pathname: dara.String("/"),
11133 Method: dara.String("POST"),
11134 AuthType: dara.String("AK"),
11135 Style: dara.String("RPC"),
11136 ReqBodyType: dara.String("formData"),
11137 BodyType: dara.String("json"),
11138 }
11139 _result = &ListCloudGtmMonitorNodesResponse{}
11140 _body, _err := client.CallApi(params, req, runtime)
11141 if _err != nil {
11142 return _result, _err
11143 }
11144 _err = dara.Convert(_body, &_result)
11145 return _result, _err
11146 }
11147
11148 // Summary:
11149 //
11150 // Queries a list of health check nodes.
11151 //
11152 // @param request - ListCloudGtmMonitorNodesRequest
11153 //
11154 // @return ListCloudGtmMonitorNodesResponse
11155 func ListCloudGtmMonitorNodes(client *Client, request *ListCloudGtmMonitorNodesRequest) (_result *ListCloudGtmMonitorNodesResponse, _err error) {
11156 runtime := &dara.RuntimeOptions{}
11157 _result = &ListCloudGtmMonitorNodesResponse{}
11158 _body, _err := ListCloudGtmMonitorNodesWithOptions(client,request, runtime)
11159 if _err != nil {
11160 return _result, _err
11161 }
11162 _result = _body
11163 return _result, _err
11164 }
11165
11166 // Summary:
11167 //
11168 // Queries a list of health check templates.
11169 //
11170 // @param request - ListCloudGtmMonitorTemplatesRequest
11171 //
11172 // @param runtime - runtime options for this request RuntimeOptions
11173 //
11174 // @return ListCloudGtmMonitorTemplatesResponse
11175 func ListCloudGtmMonitorTemplatesWithOptions(client *Client, request *ListCloudGtmMonitorTemplatesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmMonitorTemplatesResponse, _err error) {
11176 if dara.BoolValue(client.EnableValidate) == true {
11177 _err = request.Validate()
11178 if _err != nil {
11179 return _result, _err
11180 }
11181 }
11182 query := map[string]interface{}{}
11183 if !dara.IsNil(request.AcceptLanguage) {
11184 query["AcceptLanguage"] = request.AcceptLanguage
11185 }
11186
11187 if !dara.IsNil(request.IpVersion) {
11188 query["IpVersion"] = request.IpVersion
11189 }
11190
11191 if !dara.IsNil(request.Name) {
11192 query["Name"] = request.Name
11193 }
11194
11195 if !dara.IsNil(request.PageNumber) {
11196 query["PageNumber"] = request.PageNumber
11197 }
11198
11199 if !dara.IsNil(request.PageSize) {
11200 query["PageSize"] = request.PageSize
11201 }
11202
11203 if !dara.IsNil(request.Protocol) {
11204 query["Protocol"] = request.Protocol
11205 }
11206
11207 req := &openapiutil.OpenApiRequest{
11208 Query: openapiutil.Query(query),
11209 }
11210 params := &openapiutil.Params{
11211 Action: dara.String("ListCloudGtmMonitorTemplates"),
11212 Version: dara.String("2015-01-09"),
11213 Protocol: dara.String("HTTPS"),
11214 Pathname: dara.String("/"),
11215 Method: dara.String("POST"),
11216 AuthType: dara.String("AK"),
11217 Style: dara.String("RPC"),
11218 ReqBodyType: dara.String("formData"),
11219 BodyType: dara.String("json"),
11220 }
11221 _result = &ListCloudGtmMonitorTemplatesResponse{}
11222 _body, _err := client.CallApi(params, req, runtime)
11223 if _err != nil {
11224 return _result, _err
11225 }
11226 _err = dara.Convert(_body, &_result)
11227 return _result, _err
11228 }
11229
11230 // Summary:
11231 //
11232 // Queries a list of health check templates.
11233 //
11234 // @param request - ListCloudGtmMonitorTemplatesRequest
11235 //
11236 // @return ListCloudGtmMonitorTemplatesResponse
11237 func ListCloudGtmMonitorTemplates(client *Client, request *ListCloudGtmMonitorTemplatesRequest) (_result *ListCloudGtmMonitorTemplatesResponse, _err error) {
11238 runtime := &dara.RuntimeOptions{}
11239 _result = &ListCloudGtmMonitorTemplatesResponse{}
11240 _body, _err := ListCloudGtmMonitorTemplatesWithOptions(client,request, runtime)
11241 if _err != nil {
11242 return _result, _err
11243 }
11244 _result = _body
11245 return _result, _err
11246 }
11247
11248 // Summary:
11249 //
11250 // 查询递归解析内置权威解析记录
11251 //
11252 // @param request - ListRecursionRecordsRequest
11253 //
11254 // @param runtime - runtime options for this request RuntimeOptions
11255 //
11256 // @return ListRecursionRecordsResponse
11257 func ListRecursionRecordsWithOptions(client *Client, request *ListRecursionRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRecursionRecordsResponse, _err error) {
11258 if dara.BoolValue(client.EnableValidate) == true {
11259 _err = request.Validate()
11260 if _err != nil {
11261 return _result, _err
11262 }
11263 }
11264 query := map[string]interface{}{}
11265 if !dara.IsNil(request.Enable) {
11266 query["Enable"] = request.Enable
11267 }
11268
11269 if !dara.IsNil(request.MaxResults) {
11270 query["MaxResults"] = request.MaxResults
11271 }
11272
11273 if !dara.IsNil(request.NextToken) {
11274 query["NextToken"] = request.NextToken
11275 }
11276
11277 if !dara.IsNil(request.PageNumber) {
11278 query["PageNumber"] = request.PageNumber
11279 }
11280
11281 if !dara.IsNil(request.PageSize) {
11282 query["PageSize"] = request.PageSize
11283 }
11284
11285 if !dara.IsNil(request.Remark) {
11286 query["Remark"] = request.Remark
11287 }
11288
11289 if !dara.IsNil(request.RequestSource) {
11290 query["RequestSource"] = request.RequestSource
11291 }
11292
11293 if !dara.IsNil(request.Rr) {
11294 query["Rr"] = request.Rr
11295 }
11296
11297 if !dara.IsNil(request.Ttl) {
11298 query["Ttl"] = request.Ttl
11299 }
11300
11301 if !dara.IsNil(request.Type) {
11302 query["Type"] = request.Type
11303 }
11304
11305 if !dara.IsNil(request.Weight) {
11306 query["Weight"] = request.Weight
11307 }
11308
11309 if !dara.IsNil(request.ZoneId) {
11310 query["ZoneId"] = request.ZoneId
11311 }
11312
11313 req := &openapiutil.OpenApiRequest{
11314 Query: openapiutil.Query(query),
11315 }
11316 params := &openapiutil.Params{
11317 Action: dara.String("ListRecursionRecords"),
11318 Version: dara.String("2015-01-09"),
11319 Protocol: dara.String("HTTPS"),
11320 Pathname: dara.String("/"),
11321 Method: dara.String("POST"),
11322 AuthType: dara.String("AK"),
11323 Style: dara.String("RPC"),
11324 ReqBodyType: dara.String("formData"),
11325 BodyType: dara.String("json"),
11326 }
11327 _result = &ListRecursionRecordsResponse{}
11328 _body, _err := client.CallApi(params, req, runtime)
11329 if _err != nil {
11330 return _result, _err
11331 }
11332 _err = dara.Convert(_body, &_result)
11333 return _result, _err
11334 }
11335
11336 // Summary:
11337 //
11338 // 查询递归解析内置权威解析记录
11339 //
11340 // @param request - ListRecursionRecordsRequest
11341 //
11342 // @return ListRecursionRecordsResponse
11343 func ListRecursionRecords(client *Client, request *ListRecursionRecordsRequest) (_result *ListRecursionRecordsResponse, _err error) {
11344 runtime := &dara.RuntimeOptions{}
11345 _result = &ListRecursionRecordsResponse{}
11346 _body, _err := ListRecursionRecordsWithOptions(client,request, runtime)
11347 if _err != nil {
11348 return _result, _err
11349 }
11350 _result = _body
11351 return _result, _err
11352 }
11353
11354 // Summary:
11355 //
11356 // 查询递归解析内置权威域名zone
11357 //
11358 // @param request - ListRecursionZonesRequest
11359 //
11360 // @param runtime - runtime options for this request RuntimeOptions
11361 //
11362 // @return ListRecursionZonesResponse
11363 func ListRecursionZonesWithOptions(client *Client, request *ListRecursionZonesRequest, runtime *dara.RuntimeOptions) (_result *ListRecursionZonesResponse, _err error) {
11364 if dara.BoolValue(client.EnableValidate) == true {
11365 _err = request.Validate()
11366 if _err != nil {
11367 return _result, _err
11368 }
11369 }
11370 query := map[string]interface{}{}
11371 if !dara.IsNil(request.MaxResults) {
11372 query["MaxResults"] = request.MaxResults
11373 }
11374
11375 if !dara.IsNil(request.NextToken) {
11376 query["NextToken"] = request.NextToken
11377 }
11378
11379 if !dara.IsNil(request.PageNumber) {
11380 query["PageNumber"] = request.PageNumber
11381 }
11382
11383 if !dara.IsNil(request.PageSize) {
11384 query["PageSize"] = request.PageSize
11385 }
11386
11387 if !dara.IsNil(request.Remark) {
11388 query["Remark"] = request.Remark
11389 }
11390
11391 if !dara.IsNil(request.ZoneName) {
11392 query["ZoneName"] = request.ZoneName
11393 }
11394
11395 req := &openapiutil.OpenApiRequest{
11396 Query: openapiutil.Query(query),
11397 }
11398 params := &openapiutil.Params{
11399 Action: dara.String("ListRecursionZones"),
11400 Version: dara.String("2015-01-09"),
11401 Protocol: dara.String("HTTPS"),
11402 Pathname: dara.String("/"),
11403 Method: dara.String("POST"),
11404 AuthType: dara.String("AK"),
11405 Style: dara.String("RPC"),
11406 ReqBodyType: dara.String("formData"),
11407 BodyType: dara.String("json"),
11408 }
11409 _result = &ListRecursionZonesResponse{}
11410 _body, _err := client.CallApi(params, req, runtime)
11411 if _err != nil {
11412 return _result, _err
11413 }
11414 _err = dara.Convert(_body, &_result)
11415 return _result, _err
11416 }
11417
11418 // Summary:
11419 //
11420 // 查询递归解析内置权威域名zone
11421 //
11422 // @param request - ListRecursionZonesRequest
11423 //
11424 // @return ListRecursionZonesResponse
11425 func ListRecursionZones(client *Client, request *ListRecursionZonesRequest) (_result *ListRecursionZonesResponse, _err error) {
11426 runtime := &dara.RuntimeOptions{}
11427 _result = &ListRecursionZonesResponse{}
11428 _body, _err := ListRecursionZonesWithOptions(client,request, runtime)
11429 if _err != nil {
11430 return _result, _err
11431 }
11432 _result = _body
11433 return _result, _err
11434 }
11435
11436 // Summary:
11437 //
11438 // Queries resources by tag.
11439 //
11440 // Description:
11441 //
11442 // Set ResourceId.N or Tag.N that consists of Tag.N.Key and Tag.N.Value in the request to specify the object to be queried.
11443 //
11444 // - Tag.N is a resource tag that consists of a key-value pair. If you set only Tag.N.Key, all tag values that are assigned to the specified key are returned. If you set only Tag.N.Value, an error message is returned.
11445 //
11446 // - If you set both Tag.N and ResourceId.N to filter tags, ResourceId.N must match all specified key-value pairs.
11447 //
11448 // - If you specify multiple key-value pairs, resources that contain these key-value pairs are returned.
11449 //
11450 // @param request - ListTagResourcesRequest
11451 //
11452 // @param runtime - runtime options for this request RuntimeOptions
11453 //
11454 // @return ListTagResourcesResponse
11455 func ListTagResourcesWithOptions(client *Client, request *ListTagResourcesRequest, runtime *dara.RuntimeOptions) (_result *ListTagResourcesResponse, _err error) {
11456 if dara.BoolValue(client.EnableValidate) == true {
11457 _err = request.Validate()
11458 if _err != nil {
11459 return _result, _err
11460 }
11461 }
11462 query := map[string]interface{}{}
11463 if !dara.IsNil(request.Lang) {
11464 query["Lang"] = request.Lang
11465 }
11466
11467 if !dara.IsNil(request.NextToken) {
11468 query["NextToken"] = request.NextToken
11469 }
11470
11471 if !dara.IsNil(request.ResourceId) {
11472 query["ResourceId"] = request.ResourceId
11473 }
11474
11475 if !dara.IsNil(request.ResourceType) {
11476 query["ResourceType"] = request.ResourceType
11477 }
11478
11479 if !dara.IsNil(request.Tag) {
11480 query["Tag"] = request.Tag
11481 }
11482
11483 req := &openapiutil.OpenApiRequest{
11484 Query: openapiutil.Query(query),
11485 }
11486 params := &openapiutil.Params{
11487 Action: dara.String("ListTagResources"),
11488 Version: dara.String("2015-01-09"),
11489 Protocol: dara.String("HTTPS"),
11490 Pathname: dara.String("/"),
11491 Method: dara.String("POST"),
11492 AuthType: dara.String("AK"),
11493 Style: dara.String("RPC"),
11494 ReqBodyType: dara.String("formData"),
11495 BodyType: dara.String("json"),
11496 }
11497 _result = &ListTagResourcesResponse{}
11498 _body, _err := client.CallApi(params, req, runtime)
11499 if _err != nil {
11500 return _result, _err
11501 }
11502 _err = dara.Convert(_body, &_result)
11503 return _result, _err
11504 }
11505
11506 // Summary:
11507 //
11508 // Queries resources by tag.
11509 //
11510 // Description:
11511 //
11512 // Set ResourceId.N or Tag.N that consists of Tag.N.Key and Tag.N.Value in the request to specify the object to be queried.
11513 //
11514 // - Tag.N is a resource tag that consists of a key-value pair. If you set only Tag.N.Key, all tag values that are assigned to the specified key are returned. If you set only Tag.N.Value, an error message is returned.
11515 //
11516 // - If you set both Tag.N and ResourceId.N to filter tags, ResourceId.N must match all specified key-value pairs.
11517 //
11518 // - If you specify multiple key-value pairs, resources that contain these key-value pairs are returned.
11519 //
11520 // @param request - ListTagResourcesRequest
11521 //
11522 // @return ListTagResourcesResponse
11523 func ListTagResources(client *Client, request *ListTagResourcesRequest) (_result *ListTagResourcesResponse, _err error) {
11524 runtime := &dara.RuntimeOptions{}
11525 _result = &ListTagResourcesResponse{}
11526 _body, _err := ListTagResourcesWithOptions(client,request, runtime)
11527 if _err != nil {
11528 return _result, _err
11529 }
11530 _result = _body
11531 return _result, _err
11532 }
11533
11534 // Summary:
11535 //
11536 // Changes the names of DNS servers bound to a domain name from DNS server names provided by a third-party service provider to DNS server names provided by Alibaba Cloud DNS.
11537 //
11538 // Description:
11539 //
11540 // If the operation succeeds, the names of DNS servers change to those of Alibaba Cloud DNS servers (ending with hichina.com).
11541 //
11542 // > **Before you call this operation, make sure that your domain name has been registered with Alibaba Cloud and the DNS servers in use are not Alibaba Cloud DNS servers.
11543 //
11544 // @param request - ModifyHichinaDomainDNSRequest
11545 //
11546 // @param runtime - runtime options for this request RuntimeOptions
11547 //
11548 // @return ModifyHichinaDomainDNSResponse
11549 func ModifyHichinaDomainDNSWithOptions(client *Client, request *ModifyHichinaDomainDNSRequest, runtime *dara.RuntimeOptions) (_result *ModifyHichinaDomainDNSResponse, _err error) {
11550 if dara.BoolValue(client.EnableValidate) == true {
11551 _err = request.Validate()
11552 if _err != nil {
11553 return _result, _err
11554 }
11555 }
11556 query := map[string]interface{}{}
11557 if !dara.IsNil(request.DomainName) {
11558 query["DomainName"] = request.DomainName
11559 }
11560
11561 if !dara.IsNil(request.Lang) {
11562 query["Lang"] = request.Lang
11563 }
11564
11565 if !dara.IsNil(request.UserClientIp) {
11566 query["UserClientIp"] = request.UserClientIp
11567 }
11568
11569 req := &openapiutil.OpenApiRequest{
11570 Query: openapiutil.Query(query),
11571 }
11572 params := &openapiutil.Params{
11573 Action: dara.String("ModifyHichinaDomainDNS"),
11574 Version: dara.String("2015-01-09"),
11575 Protocol: dara.String("HTTPS"),
11576 Pathname: dara.String("/"),
11577 Method: dara.String("POST"),
11578 AuthType: dara.String("AK"),
11579 Style: dara.String("RPC"),
11580 ReqBodyType: dara.String("formData"),
11581 BodyType: dara.String("json"),
11582 }
11583 _result = &ModifyHichinaDomainDNSResponse{}
11584 _body, _err := client.CallApi(params, req, runtime)
11585 if _err != nil {
11586 return _result, _err
11587 }
11588 _err = dara.Convert(_body, &_result)
11589 return _result, _err
11590 }
11591
11592 // Summary:
11593 //
11594 // Changes the names of DNS servers bound to a domain name from DNS server names provided by a third-party service provider to DNS server names provided by Alibaba Cloud DNS.
11595 //
11596 // Description:
11597 //
11598 // If the operation succeeds, the names of DNS servers change to those of Alibaba Cloud DNS servers (ending with hichina.com).
11599 //
11600 // > **Before you call this operation, make sure that your domain name has been registered with Alibaba Cloud and the DNS servers in use are not Alibaba Cloud DNS servers.
11601 //
11602 // @param request - ModifyHichinaDomainDNSRequest
11603 //
11604 // @return ModifyHichinaDomainDNSResponse
11605 func ModifyHichinaDomainDNS(client *Client, request *ModifyHichinaDomainDNSRequest) (_result *ModifyHichinaDomainDNSResponse, _err error) {
11606 runtime := &dara.RuntimeOptions{}
11607 _result = &ModifyHichinaDomainDNSResponse{}
11608 _body, _err := ModifyHichinaDomainDNSWithOptions(client,request, runtime)
11609 if _err != nil {
11610 return _result, _err
11611 }
11612 _result = _body
11613 return _result, _err
11614 }
11615
11616 // Summary:
11617 //
11618 // Moves a domain name to another resource group.
11619 //
11620 // @param request - MoveDomainResourceGroupRequest
11621 //
11622 // @param runtime - runtime options for this request RuntimeOptions
11623 //
11624 // @return MoveDomainResourceGroupResponse
11625 func MoveDomainResourceGroupWithOptions(client *Client, request *MoveDomainResourceGroupRequest, runtime *dara.RuntimeOptions) (_result *MoveDomainResourceGroupResponse, _err error) {
11626 if dara.BoolValue(client.EnableValidate) == true {
11627 _err = request.Validate()
11628 if _err != nil {
11629 return _result, _err
11630 }
11631 }
11632 query := map[string]interface{}{}
11633 if !dara.IsNil(request.Lang) {
11634 query["Lang"] = request.Lang
11635 }
11636
11637 if !dara.IsNil(request.NewResourceGroupId) {
11638 query["NewResourceGroupId"] = request.NewResourceGroupId
11639 }
11640
11641 if !dara.IsNil(request.ResourceId) {
11642 query["ResourceId"] = request.ResourceId
11643 }
11644
11645 req := &openapiutil.OpenApiRequest{
11646 Query: openapiutil.Query(query),
11647 }
11648 params := &openapiutil.Params{
11649 Action: dara.String("MoveDomainResourceGroup"),
11650 Version: dara.String("2015-01-09"),
11651 Protocol: dara.String("HTTPS"),
11652 Pathname: dara.String("/"),
11653 Method: dara.String("POST"),
11654 AuthType: dara.String("AK"),
11655 Style: dara.String("RPC"),
11656 ReqBodyType: dara.String("formData"),
11657 BodyType: dara.String("json"),
11658 }
11659 _result = &MoveDomainResourceGroupResponse{}
11660 _body, _err := client.CallApi(params, req, runtime)
11661 if _err != nil {
11662 return _result, _err
11663 }
11664 _err = dara.Convert(_body, &_result)
11665 return _result, _err
11666 }
11667
11668 // Summary:
11669 //
11670 // Moves a domain name to another resource group.
11671 //
11672 // @param request - MoveDomainResourceGroupRequest
11673 //
11674 // @return MoveDomainResourceGroupResponse
11675 func MoveDomainResourceGroup(client *Client, request *MoveDomainResourceGroupRequest) (_result *MoveDomainResourceGroupResponse, _err error) {
11676 runtime := &dara.RuntimeOptions{}
11677 _result = &MoveDomainResourceGroupResponse{}
11678 _body, _err := MoveDomainResourceGroupWithOptions(client,request, runtime)
11679 if _err != nil {
11680 return _result, _err
11681 }
11682 _result = _body
11683 return _result, _err
11684 }
11685
11686 // @param request - MoveGtmResourceGroupRequest
11687 //
11688 // @param runtime - runtime options for this request RuntimeOptions
11689 //
11690 // @return MoveGtmResourceGroupResponse
11691 func MoveGtmResourceGroupWithOptions(client *Client, request *MoveGtmResourceGroupRequest, runtime *dara.RuntimeOptions) (_result *MoveGtmResourceGroupResponse, _err error) {
11692 if dara.BoolValue(client.EnableValidate) == true {
11693 _err = request.Validate()
11694 if _err != nil {
11695 return _result, _err
11696 }
11697 }
11698 query := map[string]interface{}{}
11699 if !dara.IsNil(request.Lang) {
11700 query["Lang"] = request.Lang
11701 }
11702
11703 if !dara.IsNil(request.NewResourceGroupId) {
11704 query["NewResourceGroupId"] = request.NewResourceGroupId
11705 }
11706
11707 if !dara.IsNil(request.ResourceId) {
11708 query["ResourceId"] = request.ResourceId
11709 }
11710
11711 req := &openapiutil.OpenApiRequest{
11712 Query: openapiutil.Query(query),
11713 }
11714 params := &openapiutil.Params{
11715 Action: dara.String("MoveGtmResourceGroup"),
11716 Version: dara.String("2015-01-09"),
11717 Protocol: dara.String("HTTPS"),
11718 Pathname: dara.String("/"),
11719 Method: dara.String("POST"),
11720 AuthType: dara.String("AK"),
11721 Style: dara.String("RPC"),
11722 ReqBodyType: dara.String("formData"),
11723 BodyType: dara.String("json"),
11724 }
11725 _result = &MoveGtmResourceGroupResponse{}
11726 _body, _err := client.CallApi(params, req, runtime)
11727 if _err != nil {
11728 return _result, _err
11729 }
11730 _err = dara.Convert(_body, &_result)
11731 return _result, _err
11732 }
11733
11734 // @param request - MoveGtmResourceGroupRequest
11735 //
11736 // @return MoveGtmResourceGroupResponse
11737 func MoveGtmResourceGroup(client *Client, request *MoveGtmResourceGroupRequest) (_result *MoveGtmResourceGroupResponse, _err error) {
11738 runtime := &dara.RuntimeOptions{}
11739 _result = &MoveGtmResourceGroupResponse{}
11740 _body, _err := MoveGtmResourceGroupWithOptions(client,request, runtime)
11741 if _err != nil {
11742 return _result, _err
11743 }
11744 _result = _body
11745 return _result, _err
11746 }
11747
11748 // Summary:
11749 //
11750 // Adds or deletes domain names and Domain Name System (DNS) records in batches.
11751 //
11752 // Description:
11753 //
11754 // Scenario: You need to execute a large number of tasks related to DNS resolution and you do not have high requirements for efficiency.
11755 //
11756 // @param request - OperateBatchDomainRequest
11757 //
11758 // @param runtime - runtime options for this request RuntimeOptions
11759 //
11760 // @return OperateBatchDomainResponse
11761 func OperateBatchDomainWithOptions(client *Client, request *OperateBatchDomainRequest, runtime *dara.RuntimeOptions) (_result *OperateBatchDomainResponse, _err error) {
11762 if dara.BoolValue(client.EnableValidate) == true {
11763 _err = request.Validate()
11764 if _err != nil {
11765 return _result, _err
11766 }
11767 }
11768 query := map[string]interface{}{}
11769 if !dara.IsNil(request.DomainRecordInfo) {
11770 query["DomainRecordInfo"] = request.DomainRecordInfo
11771 }
11772
11773 if !dara.IsNil(request.Lang) {
11774 query["Lang"] = request.Lang
11775 }
11776
11777 if !dara.IsNil(request.Type) {
11778 query["Type"] = request.Type
11779 }
11780
11781 req := &openapiutil.OpenApiRequest{
11782 Query: openapiutil.Query(query),
11783 }
11784 params := &openapiutil.Params{
11785 Action: dara.String("OperateBatchDomain"),
11786 Version: dara.String("2015-01-09"),
11787 Protocol: dara.String("HTTPS"),
11788 Pathname: dara.String("/"),
11789 Method: dara.String("POST"),
11790 AuthType: dara.String("AK"),
11791 Style: dara.String("RPC"),
11792 ReqBodyType: dara.String("formData"),
11793 BodyType: dara.String("json"),
11794 }
11795 _result = &OperateBatchDomainResponse{}
11796 _body, _err := client.CallApi(params, req, runtime)
11797 if _err != nil {
11798 return _result, _err
11799 }
11800 _err = dara.Convert(_body, &_result)
11801 return _result, _err
11802 }
11803
11804 // Summary:
11805 //
11806 // Adds or deletes domain names and Domain Name System (DNS) records in batches.
11807 //
11808 // Description:
11809 //
11810 // Scenario: You need to execute a large number of tasks related to DNS resolution and you do not have high requirements for efficiency.
11811 //
11812 // @param request - OperateBatchDomainRequest
11813 //
11814 // @return OperateBatchDomainResponse
11815 func OperateBatchDomain(client *Client, request *OperateBatchDomainRequest) (_result *OperateBatchDomainResponse, _err error) {
11816 runtime := &dara.RuntimeOptions{}
11817 _result = &OperateBatchDomainResponse{}
11818 _body, _err := OperateBatchDomainWithOptions(client,request, runtime)
11819 if _err != nil {
11820 return _result, _err
11821 }
11822 _result = _body
11823 return _result, _err
11824 }
11825
11826 // Summary:
11827 //
11828 // 暂停公共DNS服务
11829 //
11830 // @param request - PausePdnsServiceRequest
11831 //
11832 // @param runtime - runtime options for this request RuntimeOptions
11833 //
11834 // @return PausePdnsServiceResponse
11835 func PausePdnsServiceWithOptions(client *Client, request *PausePdnsServiceRequest, runtime *dara.RuntimeOptions) (_result *PausePdnsServiceResponse, _err error) {
11836 if dara.BoolValue(client.EnableValidate) == true {
11837 _err = request.Validate()
11838 if _err != nil {
11839 return _result, _err
11840 }
11841 }
11842 query := map[string]interface{}{}
11843 if !dara.IsNil(request.Lang) {
11844 query["Lang"] = request.Lang
11845 }
11846
11847 if !dara.IsNil(request.ServiceType) {
11848 query["ServiceType"] = request.ServiceType
11849 }
11850
11851 req := &openapiutil.OpenApiRequest{
11852 Query: openapiutil.Query(query),
11853 }
11854 params := &openapiutil.Params{
11855 Action: dara.String("PausePdnsService"),
11856 Version: dara.String("2015-01-09"),
11857 Protocol: dara.String("HTTPS"),
11858 Pathname: dara.String("/"),
11859 Method: dara.String("POST"),
11860 AuthType: dara.String("AK"),
11861 Style: dara.String("RPC"),
11862 ReqBodyType: dara.String("formData"),
11863 BodyType: dara.String("json"),
11864 }
11865 _result = &PausePdnsServiceResponse{}
11866 _body, _err := client.CallApi(params, req, runtime)
11867 if _err != nil {
11868 return _result, _err
11869 }
11870 _err = dara.Convert(_body, &_result)
11871 return _result, _err
11872 }
11873
11874 // Summary:
11875 //
11876 // 暂停公共DNS服务
11877 //
11878 // @param request - PausePdnsServiceRequest
11879 //
11880 // @return PausePdnsServiceResponse
11881 func PausePdnsService(client *Client, request *PausePdnsServiceRequest) (_result *PausePdnsServiceResponse, _err error) {
11882 runtime := &dara.RuntimeOptions{}
11883 _result = &PausePdnsServiceResponse{}
11884 _body, _err := PausePdnsServiceWithOptions(client,request, runtime)
11885 if _err != nil {
11886 return _result, _err
11887 }
11888 _result = _body
11889 return _result, _err
11890 }
11891
11892 // Summary:
11893 //
11894 // You can call this operation to preview a disaster recovery plan of a Global Traffic Manager (GTM) instance.
11895 //
11896 // @param request - PreviewGtmRecoveryPlanRequest
11897 //
11898 // @param runtime - runtime options for this request RuntimeOptions
11899 //
11900 // @return PreviewGtmRecoveryPlanResponse
11901 func PreviewGtmRecoveryPlanWithOptions(client *Client, request *PreviewGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *PreviewGtmRecoveryPlanResponse, _err error) {
11902 if dara.BoolValue(client.EnableValidate) == true {
11903 _err = request.Validate()
11904 if _err != nil {
11905 return _result, _err
11906 }
11907 }
11908 query := map[string]interface{}{}
11909 if !dara.IsNil(request.Lang) {
11910 query["Lang"] = request.Lang
11911 }
11912
11913 if !dara.IsNil(request.PageNumber) {
11914 query["PageNumber"] = request.PageNumber
11915 }
11916
11917 if !dara.IsNil(request.PageSize) {
11918 query["PageSize"] = request.PageSize
11919 }
11920
11921 if !dara.IsNil(request.RecoveryPlanId) {
11922 query["RecoveryPlanId"] = request.RecoveryPlanId
11923 }
11924
11925 req := &openapiutil.OpenApiRequest{
11926 Query: openapiutil.Query(query),
11927 }
11928 params := &openapiutil.Params{
11929 Action: dara.String("PreviewGtmRecoveryPlan"),
11930 Version: dara.String("2015-01-09"),
11931 Protocol: dara.String("HTTPS"),
11932 Pathname: dara.String("/"),
11933 Method: dara.String("POST"),
11934 AuthType: dara.String("AK"),
11935 Style: dara.String("RPC"),
11936 ReqBodyType: dara.String("formData"),
11937 BodyType: dara.String("json"),
11938 }
11939 _result = &PreviewGtmRecoveryPlanResponse{}
11940 _body, _err := client.CallApi(params, req, runtime)
11941 if _err != nil {
11942 return _result, _err
11943 }
11944 _err = dara.Convert(_body, &_result)
11945 return _result, _err
11946 }
11947
11948 // Summary:
11949 //
11950 // You can call this operation to preview a disaster recovery plan of a Global Traffic Manager (GTM) instance.
11951 //
11952 // @param request - PreviewGtmRecoveryPlanRequest
11953 //
11954 // @return PreviewGtmRecoveryPlanResponse
11955 func PreviewGtmRecoveryPlan(client *Client, request *PreviewGtmRecoveryPlanRequest) (_result *PreviewGtmRecoveryPlanResponse, _err error) {
11956 runtime := &dara.RuntimeOptions{}
11957 _result = &PreviewGtmRecoveryPlanResponse{}
11958 _body, _err := PreviewGtmRecoveryPlanWithOptions(client,request, runtime)
11959 if _err != nil {
11960 return _result, _err
11961 }
11962 _result = _body
11963 return _result, _err
11964 }
11965
11966 // Summary:
11967 //
11968 // 删除公共DNS AppKey
11969 //
11970 // @param request - RemovePdnsAppKeyRequest
11971 //
11972 // @param runtime - runtime options for this request RuntimeOptions
11973 //
11974 // @return RemovePdnsAppKeyResponse
11975 func RemovePdnsAppKeyWithOptions(client *Client, request *RemovePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *RemovePdnsAppKeyResponse, _err error) {
11976 if dara.BoolValue(client.EnableValidate) == true {
11977 _err = request.Validate()
11978 if _err != nil {
11979 return _result, _err
11980 }
11981 }
11982 query := map[string]interface{}{}
11983 if !dara.IsNil(request.AppKeyId) {
11984 query["AppKeyId"] = request.AppKeyId
11985 }
11986
11987 if !dara.IsNil(request.Lang) {
11988 query["Lang"] = request.Lang
11989 }
11990
11991 req := &openapiutil.OpenApiRequest{
11992 Query: openapiutil.Query(query),
11993 }
11994 params := &openapiutil.Params{
11995 Action: dara.String("RemovePdnsAppKey"),
11996 Version: dara.String("2015-01-09"),
11997 Protocol: dara.String("HTTPS"),
11998 Pathname: dara.String("/"),
11999 Method: dara.String("POST"),
12000 AuthType: dara.String("AK"),
12001 Style: dara.String("RPC"),
12002 ReqBodyType: dara.String("formData"),
12003 BodyType: dara.String("json"),
12004 }
12005 _result = &RemovePdnsAppKeyResponse{}
12006 _body, _err := client.CallApi(params, req, runtime)
12007 if _err != nil {
12008 return _result, _err
12009 }
12010 _err = dara.Convert(_body, &_result)
12011 return _result, _err
12012 }
12013
12014 // Summary:
12015 //
12016 // 删除公共DNS AppKey
12017 //
12018 // @param request - RemovePdnsAppKeyRequest
12019 //
12020 // @return RemovePdnsAppKeyResponse
12021 func RemovePdnsAppKey(client *Client, request *RemovePdnsAppKeyRequest) (_result *RemovePdnsAppKeyResponse, _err error) {
12022 runtime := &dara.RuntimeOptions{}
12023 _result = &RemovePdnsAppKeyResponse{}
12024 _body, _err := RemovePdnsAppKeyWithOptions(client,request, runtime)
12025 if _err != nil {
12026 return _result, _err
12027 }
12028 _result = _body
12029 return _result, _err
12030 }
12031
12032 // Summary:
12033 //
12034 // 删除公共DNS Udp Ip地址段
12035 //
12036 // @param request - RemovePdnsUdpIpSegmentRequest
12037 //
12038 // @param runtime - runtime options for this request RuntimeOptions
12039 //
12040 // @return RemovePdnsUdpIpSegmentResponse
12041 func RemovePdnsUdpIpSegmentWithOptions(client *Client, request *RemovePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *RemovePdnsUdpIpSegmentResponse, _err error) {
12042 if dara.BoolValue(client.EnableValidate) == true {
12043 _err = request.Validate()
12044 if _err != nil {
12045 return _result, _err
12046 }
12047 }
12048 query := map[string]interface{}{}
12049 if !dara.IsNil(request.Ip) {
12050 query["Ip"] = request.Ip
12051 }
12052
12053 if !dara.IsNil(request.Lang) {
12054 query["Lang"] = request.Lang
12055 }
12056
12057 req := &openapiutil.OpenApiRequest{
12058 Query: openapiutil.Query(query),
12059 }
12060 params := &openapiutil.Params{
12061 Action: dara.String("RemovePdnsUdpIpSegment"),
12062 Version: dara.String("2015-01-09"),
12063 Protocol: dara.String("HTTPS"),
12064 Pathname: dara.String("/"),
12065 Method: dara.String("POST"),
12066 AuthType: dara.String("AK"),
12067 Style: dara.String("RPC"),
12068 ReqBodyType: dara.String("formData"),
12069 BodyType: dara.String("json"),
12070 }
12071 _result = &RemovePdnsUdpIpSegmentResponse{}
12072 _body, _err := client.CallApi(params, req, runtime)
12073 if _err != nil {
12074 return _result, _err
12075 }
12076 _err = dara.Convert(_body, &_result)
12077 return _result, _err
12078 }
12079
12080 // Summary:
12081 //
12082 // 删除公共DNS Udp Ip地址段
12083 //
12084 // @param request - RemovePdnsUdpIpSegmentRequest
12085 //
12086 // @return RemovePdnsUdpIpSegmentResponse
12087 func RemovePdnsUdpIpSegment(client *Client, request *RemovePdnsUdpIpSegmentRequest) (_result *RemovePdnsUdpIpSegmentResponse, _err error) {
12088 runtime := &dara.RuntimeOptions{}
12089 _result = &RemovePdnsUdpIpSegmentResponse{}
12090 _body, _err := RemovePdnsUdpIpSegmentWithOptions(client,request, runtime)
12091 if _err != nil {
12092 return _result, _err
12093 }
12094 _result = _body
12095 return _result, _err
12096 }
12097
12098 // Summary:
12099 //
12100 // Replaces the addresses referenced by an address pool.
12101 //
12102 // @param tmpReq - ReplaceCloudGtmAddressPoolAddressRequest
12103 //
12104 // @param runtime - runtime options for this request RuntimeOptions
12105 //
12106 // @return ReplaceCloudGtmAddressPoolAddressResponse
12107 func ReplaceCloudGtmAddressPoolAddressWithOptions(client *Client, tmpReq *ReplaceCloudGtmAddressPoolAddressRequest, runtime *dara.RuntimeOptions) (_result *ReplaceCloudGtmAddressPoolAddressResponse, _err error) {
12108 if dara.BoolValue(client.EnableValidate) == true {
12109 _err = tmpReq.Validate()
12110 if _err != nil {
12111 return _result, _err
12112 }
12113 }
12114 request := &ReplaceCloudGtmAddressPoolAddressShrinkRequest{}
12115 openapiutil.Convert(tmpReq, request)
12116 if !dara.IsNil(tmpReq.Addresses) {
12117 request.AddressesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Addresses, dara.String("Addresses"), dara.String("json"))
12118 }
12119
12120 query := map[string]interface{}{}
12121 if !dara.IsNil(request.AcceptLanguage) {
12122 query["AcceptLanguage"] = request.AcceptLanguage
12123 }
12124
12125 if !dara.IsNil(request.AddressPoolId) {
12126 query["AddressPoolId"] = request.AddressPoolId
12127 }
12128
12129 if !dara.IsNil(request.AddressesShrink) {
12130 query["Addresses"] = request.AddressesShrink
12131 }
12132
12133 if !dara.IsNil(request.ClientToken) {
12134 query["ClientToken"] = request.ClientToken
12135 }
12136
12137 req := &openapiutil.OpenApiRequest{
12138 Query: openapiutil.Query(query),
12139 }
12140 params := &openapiutil.Params{
12141 Action: dara.String("ReplaceCloudGtmAddressPoolAddress"),
12142 Version: dara.String("2015-01-09"),
12143 Protocol: dara.String("HTTPS"),
12144 Pathname: dara.String("/"),
12145 Method: dara.String("POST"),
12146 AuthType: dara.String("AK"),
12147 Style: dara.String("RPC"),
12148 ReqBodyType: dara.String("formData"),
12149 BodyType: dara.String("json"),
12150 }
12151 _result = &ReplaceCloudGtmAddressPoolAddressResponse{}
12152 _body, _err := client.CallApi(params, req, runtime)
12153 if _err != nil {
12154 return _result, _err
12155 }
12156 _err = dara.Convert(_body, &_result)
12157 return _result, _err
12158 }
12159
12160 // Summary:
12161 //
12162 // Replaces the addresses referenced by an address pool.
12163 //
12164 // @param request - ReplaceCloudGtmAddressPoolAddressRequest
12165 //
12166 // @return ReplaceCloudGtmAddressPoolAddressResponse
12167 func ReplaceCloudGtmAddressPoolAddress(client *Client, request *ReplaceCloudGtmAddressPoolAddressRequest) (_result *ReplaceCloudGtmAddressPoolAddressResponse, _err error) {
12168 runtime := &dara.RuntimeOptions{}
12169 _result = &ReplaceCloudGtmAddressPoolAddressResponse{}
12170 _body, _err := ReplaceCloudGtmAddressPoolAddressWithOptions(client,request, runtime)
12171 if _err != nil {
12172 return _result, _err
12173 }
12174 _result = _body
12175 return _result, _err
12176 }
12177
12178 // Summary:
12179 //
12180 // Replaces address pools that are associated with a Global Traffic Manager (GTM) 3.0 instance with new address pools.
12181 //
12182 // @param tmpReq - ReplaceCloudGtmInstanceConfigAddressPoolRequest
12183 //
12184 // @param runtime - runtime options for this request RuntimeOptions
12185 //
12186 // @return ReplaceCloudGtmInstanceConfigAddressPoolResponse
12187 func ReplaceCloudGtmInstanceConfigAddressPoolWithOptions(client *Client, tmpReq *ReplaceCloudGtmInstanceConfigAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *ReplaceCloudGtmInstanceConfigAddressPoolResponse, _err error) {
12188 if dara.BoolValue(client.EnableValidate) == true {
12189 _err = tmpReq.Validate()
12190 if _err != nil {
12191 return _result, _err
12192 }
12193 }
12194 request := &ReplaceCloudGtmInstanceConfigAddressPoolShrinkRequest{}
12195 openapiutil.Convert(tmpReq, request)
12196 if !dara.IsNil(tmpReq.AddressPools) {
12197 request.AddressPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AddressPools, dara.String("AddressPools"), dara.String("json"))
12198 }
12199
12200 query := map[string]interface{}{}
12201 if !dara.IsNil(request.AcceptLanguage) {
12202 query["AcceptLanguage"] = request.AcceptLanguage
12203 }
12204
12205 if !dara.IsNil(request.AddressPoolsShrink) {
12206 query["AddressPools"] = request.AddressPoolsShrink
12207 }
12208
12209 if !dara.IsNil(request.ClientToken) {
12210 query["ClientToken"] = request.ClientToken
12211 }
12212
12213 if !dara.IsNil(request.ConfigId) {
12214 query["ConfigId"] = request.ConfigId
12215 }
12216
12217 if !dara.IsNil(request.InstanceId) {
12218 query["InstanceId"] = request.InstanceId
12219 }
12220
12221 req := &openapiutil.OpenApiRequest{
12222 Query: openapiutil.Query(query),
12223 }
12224 params := &openapiutil.Params{
12225 Action: dara.String("ReplaceCloudGtmInstanceConfigAddressPool"),
12226 Version: dara.String("2015-01-09"),
12227 Protocol: dara.String("HTTPS"),
12228 Pathname: dara.String("/"),
12229 Method: dara.String("POST"),
12230 AuthType: dara.String("AK"),
12231 Style: dara.String("RPC"),
12232 ReqBodyType: dara.String("formData"),
12233 BodyType: dara.String("json"),
12234 }
12235 _result = &ReplaceCloudGtmInstanceConfigAddressPoolResponse{}
12236 _body, _err := client.CallApi(params, req, runtime)
12237 if _err != nil {
12238 return _result, _err
12239 }
12240 _err = dara.Convert(_body, &_result)
12241 return _result, _err
12242 }
12243
12244 // Summary:
12245 //
12246 // Replaces address pools that are associated with a Global Traffic Manager (GTM) 3.0 instance with new address pools.
12247 //
12248 // @param request - ReplaceCloudGtmInstanceConfigAddressPoolRequest
12249 //
12250 // @return ReplaceCloudGtmInstanceConfigAddressPoolResponse
12251 func ReplaceCloudGtmInstanceConfigAddressPool(client *Client, request *ReplaceCloudGtmInstanceConfigAddressPoolRequest) (_result *ReplaceCloudGtmInstanceConfigAddressPoolResponse, _err error) {
12252 runtime := &dara.RuntimeOptions{}
12253 _result = &ReplaceCloudGtmInstanceConfigAddressPoolResponse{}
12254 _body, _err := ReplaceCloudGtmInstanceConfigAddressPoolWithOptions(client,request, runtime)
12255 if _err != nil {
12256 return _result, _err
12257 }
12258 _result = _body
12259 return _result, _err
12260 }
12261
12262 // Summary:
12263 //
12264 // 恢复公共DNS服务
12265 //
12266 // @param request - ResumePdnsServiceRequest
12267 //
12268 // @param runtime - runtime options for this request RuntimeOptions
12269 //
12270 // @return ResumePdnsServiceResponse
12271 func ResumePdnsServiceWithOptions(client *Client, request *ResumePdnsServiceRequest, runtime *dara.RuntimeOptions) (_result *ResumePdnsServiceResponse, _err error) {
12272 if dara.BoolValue(client.EnableValidate) == true {
12273 _err = request.Validate()
12274 if _err != nil {
12275 return _result, _err
12276 }
12277 }
12278 query := map[string]interface{}{}
12279 if !dara.IsNil(request.Lang) {
12280 query["Lang"] = request.Lang
12281 }
12282
12283 if !dara.IsNil(request.ServiceType) {
12284 query["ServiceType"] = request.ServiceType
12285 }
12286
12287 req := &openapiutil.OpenApiRequest{
12288 Query: openapiutil.Query(query),
12289 }
12290 params := &openapiutil.Params{
12291 Action: dara.String("ResumePdnsService"),
12292 Version: dara.String("2015-01-09"),
12293 Protocol: dara.String("HTTPS"),
12294 Pathname: dara.String("/"),
12295 Method: dara.String("POST"),
12296 AuthType: dara.String("AK"),
12297 Style: dara.String("RPC"),
12298 ReqBodyType: dara.String("formData"),
12299 BodyType: dara.String("json"),
12300 }
12301 _result = &ResumePdnsServiceResponse{}
12302 _body, _err := client.CallApi(params, req, runtime)
12303 if _err != nil {
12304 return _result, _err
12305 }
12306 _err = dara.Convert(_body, &_result)
12307 return _result, _err
12308 }
12309
12310 // Summary:
12311 //
12312 // 恢复公共DNS服务
12313 //
12314 // @param request - ResumePdnsServiceRequest
12315 //
12316 // @return ResumePdnsServiceResponse
12317 func ResumePdnsService(client *Client, request *ResumePdnsServiceRequest) (_result *ResumePdnsServiceResponse, _err error) {
12318 runtime := &dara.RuntimeOptions{}
12319 _result = &ResumePdnsServiceResponse{}
12320 _body, _err := ResumePdnsServiceWithOptions(client,request, runtime)
12321 if _err != nil {
12322 return _result, _err
12323 }
12324 _result = _body
12325 return _result, _err
12326 }
12327
12328 // Summary:
12329 //
12330 // Retrieves a domain name.
12331 //
12332 // Description:
12333 //
12334 // To retrieve a domain name, you must verify a text (TXT) record. Therefore, before you call this API operation to retrieve a domain name, call the [GetTxtRecordForVerify](https://www.alibabacloud.com/help/en/alibaba-cloud-dns/latest/generating-a-txt-record) operation to generate a TXT record.
12335 //
12336 // @param request - RetrieveDomainRequest
12337 //
12338 // @param runtime - runtime options for this request RuntimeOptions
12339 //
12340 // @return RetrieveDomainResponse
12341 func RetrieveDomainWithOptions(client *Client, request *RetrieveDomainRequest, runtime *dara.RuntimeOptions) (_result *RetrieveDomainResponse, _err error) {
12342 if dara.BoolValue(client.EnableValidate) == true {
12343 _err = request.Validate()
12344 if _err != nil {
12345 return _result, _err
12346 }
12347 }
12348 query := map[string]interface{}{}
12349 if !dara.IsNil(request.DomainName) {
12350 query["DomainName"] = request.DomainName
12351 }
12352
12353 if !dara.IsNil(request.Lang) {
12354 query["Lang"] = request.Lang
12355 }
12356
12357 req := &openapiutil.OpenApiRequest{
12358 Query: openapiutil.Query(query),
12359 }
12360 params := &openapiutil.Params{
12361 Action: dara.String("RetrieveDomain"),
12362 Version: dara.String("2015-01-09"),
12363 Protocol: dara.String("HTTPS"),
12364 Pathname: dara.String("/"),
12365 Method: dara.String("POST"),
12366 AuthType: dara.String("AK"),
12367 Style: dara.String("RPC"),
12368 ReqBodyType: dara.String("formData"),
12369 BodyType: dara.String("json"),
12370 }
12371 _result = &RetrieveDomainResponse{}
12372 _body, _err := client.CallApi(params, req, runtime)
12373 if _err != nil {
12374 return _result, _err
12375 }
12376 _err = dara.Convert(_body, &_result)
12377 return _result, _err
12378 }
12379
12380 // Summary:
12381 //
12382 // Retrieves a domain name.
12383 //
12384 // Description:
12385 //
12386 // To retrieve a domain name, you must verify a text (TXT) record. Therefore, before you call this API operation to retrieve a domain name, call the [GetTxtRecordForVerify](https://www.alibabacloud.com/help/en/alibaba-cloud-dns/latest/generating-a-txt-record) operation to generate a TXT record.
12387 //
12388 // @param request - RetrieveDomainRequest
12389 //
12390 // @return RetrieveDomainResponse
12391 func RetrieveDomain(client *Client, request *RetrieveDomainRequest) (_result *RetrieveDomainResponse, _err error) {
12392 runtime := &dara.RuntimeOptions{}
12393 _result = &RetrieveDomainResponse{}
12394 _body, _err := RetrieveDomainWithOptions(client,request, runtime)
12395 if _err != nil {
12396 return _result, _err
12397 }
12398 _result = _body
12399 return _result, _err
12400 }
12401
12402 // Summary:
12403 //
12404 // Rolls back a disaster recovery plan.
12405 //
12406 // @param request - RollbackGtmRecoveryPlanRequest
12407 //
12408 // @param runtime - runtime options for this request RuntimeOptions
12409 //
12410 // @return RollbackGtmRecoveryPlanResponse
12411 func RollbackGtmRecoveryPlanWithOptions(client *Client, request *RollbackGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *RollbackGtmRecoveryPlanResponse, _err error) {
12412 if dara.BoolValue(client.EnableValidate) == true {
12413 _err = request.Validate()
12414 if _err != nil {
12415 return _result, _err
12416 }
12417 }
12418 query := map[string]interface{}{}
12419 if !dara.IsNil(request.Lang) {
12420 query["Lang"] = request.Lang
12421 }
12422
12423 if !dara.IsNil(request.RecoveryPlanId) {
12424 query["RecoveryPlanId"] = request.RecoveryPlanId
12425 }
12426
12427 req := &openapiutil.OpenApiRequest{
12428 Query: openapiutil.Query(query),
12429 }
12430 params := &openapiutil.Params{
12431 Action: dara.String("RollbackGtmRecoveryPlan"),
12432 Version: dara.String("2015-01-09"),
12433 Protocol: dara.String("HTTPS"),
12434 Pathname: dara.String("/"),
12435 Method: dara.String("POST"),
12436 AuthType: dara.String("AK"),
12437 Style: dara.String("RPC"),
12438 ReqBodyType: dara.String("formData"),
12439 BodyType: dara.String("json"),
12440 }
12441 _result = &RollbackGtmRecoveryPlanResponse{}
12442 _body, _err := client.CallApi(params, req, runtime)
12443 if _err != nil {
12444 return _result, _err
12445 }
12446 _err = dara.Convert(_body, &_result)
12447 return _result, _err
12448 }
12449
12450 // Summary:
12451 //
12452 // Rolls back a disaster recovery plan.
12453 //
12454 // @param request - RollbackGtmRecoveryPlanRequest
12455 //
12456 // @return RollbackGtmRecoveryPlanResponse
12457 func RollbackGtmRecoveryPlan(client *Client, request *RollbackGtmRecoveryPlanRequest) (_result *RollbackGtmRecoveryPlanResponse, _err error) {
12458 runtime := &dara.RuntimeOptions{}
12459 _result = &RollbackGtmRecoveryPlanResponse{}
12460 _body, _err := RollbackGtmRecoveryPlanWithOptions(client,request, runtime)
12461 if _err != nil {
12462 return _result, _err
12463 }
12464 _result = _body
12465 return _result, _err
12466 }
12467
12468 // Summary:
12469 //
12470 // Queries a list of address pools.
12471 //
12472 // @param request - SearchCloudGtmAddressPoolsRequest
12473 //
12474 // @param runtime - runtime options for this request RuntimeOptions
12475 //
12476 // @return SearchCloudGtmAddressPoolsResponse
12477 func SearchCloudGtmAddressPoolsWithOptions(client *Client, request *SearchCloudGtmAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmAddressPoolsResponse, _err error) {
12478 if dara.BoolValue(client.EnableValidate) == true {
12479 _err = request.Validate()
12480 if _err != nil {
12481 return _result, _err
12482 }
12483 }
12484 query := map[string]interface{}{}
12485 if !dara.IsNil(request.AcceptLanguage) {
12486 query["AcceptLanguage"] = request.AcceptLanguage
12487 }
12488
12489 if !dara.IsNil(request.AddressPoolName) {
12490 query["AddressPoolName"] = request.AddressPoolName
12491 }
12492
12493 if !dara.IsNil(request.AddressPoolType) {
12494 query["AddressPoolType"] = request.AddressPoolType
12495 }
12496
12497 if !dara.IsNil(request.AvailableStatus) {
12498 query["AvailableStatus"] = request.AvailableStatus
12499 }
12500
12501 if !dara.IsNil(request.ClientToken) {
12502 query["ClientToken"] = request.ClientToken
12503 }
12504
12505 if !dara.IsNil(request.EnableStatus) {
12506 query["EnableStatus"] = request.EnableStatus
12507 }
12508
12509 if !dara.IsNil(request.HealthStatus) {
12510 query["HealthStatus"] = request.HealthStatus
12511 }
12512
12513 if !dara.IsNil(request.PageNumber) {
12514 query["PageNumber"] = request.PageNumber
12515 }
12516
12517 if !dara.IsNil(request.PageSize) {
12518 query["PageSize"] = request.PageSize
12519 }
12520
12521 if !dara.IsNil(request.Remark) {
12522 query["Remark"] = request.Remark
12523 }
12524
12525 req := &openapiutil.OpenApiRequest{
12526 Query: openapiutil.Query(query),
12527 }
12528 params := &openapiutil.Params{
12529 Action: dara.String("SearchCloudGtmAddressPools"),
12530 Version: dara.String("2015-01-09"),
12531 Protocol: dara.String("HTTPS"),
12532 Pathname: dara.String("/"),
12533 Method: dara.String("POST"),
12534 AuthType: dara.String("AK"),
12535 Style: dara.String("RPC"),
12536 ReqBodyType: dara.String("formData"),
12537 BodyType: dara.String("json"),
12538 }
12539 _result = &SearchCloudGtmAddressPoolsResponse{}
12540 _body, _err := client.CallApi(params, req, runtime)
12541 if _err != nil {
12542 return _result, _err
12543 }
12544 _err = dara.Convert(_body, &_result)
12545 return _result, _err
12546 }
12547
12548 // Summary:
12549 //
12550 // Queries a list of address pools.
12551 //
12552 // @param request - SearchCloudGtmAddressPoolsRequest
12553 //
12554 // @return SearchCloudGtmAddressPoolsResponse
12555 func SearchCloudGtmAddressPools(client *Client, request *SearchCloudGtmAddressPoolsRequest) (_result *SearchCloudGtmAddressPoolsResponse, _err error) {
12556 runtime := &dara.RuntimeOptions{}
12557 _result = &SearchCloudGtmAddressPoolsResponse{}
12558 _body, _err := SearchCloudGtmAddressPoolsWithOptions(client,request, runtime)
12559 if _err != nil {
12560 return _result, _err
12561 }
12562 _result = _body
12563 return _result, _err
12564 }
12565
12566 // Summary:
12567 //
12568 // Queries a list of addresses based on address names, descriptions, health check templates referenced by the addresses, or address IDs.
12569 //
12570 // @param request - SearchCloudGtmAddressesRequest
12571 //
12572 // @param runtime - runtime options for this request RuntimeOptions
12573 //
12574 // @return SearchCloudGtmAddressesResponse
12575 func SearchCloudGtmAddressesWithOptions(client *Client, request *SearchCloudGtmAddressesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmAddressesResponse, _err error) {
12576 if dara.BoolValue(client.EnableValidate) == true {
12577 _err = request.Validate()
12578 if _err != nil {
12579 return _result, _err
12580 }
12581 }
12582 query := map[string]interface{}{}
12583 if !dara.IsNil(request.AcceptLanguage) {
12584 query["AcceptLanguage"] = request.AcceptLanguage
12585 }
12586
12587 if !dara.IsNil(request.Address) {
12588 query["Address"] = request.Address
12589 }
12590
12591 if !dara.IsNil(request.AddressId) {
12592 query["AddressId"] = request.AddressId
12593 }
12594
12595 if !dara.IsNil(request.AvailableStatus) {
12596 query["AvailableStatus"] = request.AvailableStatus
12597 }
12598
12599 if !dara.IsNil(request.EnableStatus) {
12600 query["EnableStatus"] = request.EnableStatus
12601 }
12602
12603 if !dara.IsNil(request.HealthStatus) {
12604 query["HealthStatus"] = request.HealthStatus
12605 }
12606
12607 if !dara.IsNil(request.MonitorTemplateName) {
12608 query["MonitorTemplateName"] = request.MonitorTemplateName
12609 }
12610
12611 if !dara.IsNil(request.NameSearchCondition) {
12612 query["NameSearchCondition"] = request.NameSearchCondition
12613 }
12614
12615 if !dara.IsNil(request.Names) {
12616 query["Names"] = request.Names
12617 }
12618
12619 if !dara.IsNil(request.PageNumber) {
12620 query["PageNumber"] = request.PageNumber
12621 }
12622
12623 if !dara.IsNil(request.PageSize) {
12624 query["PageSize"] = request.PageSize
12625 }
12626
12627 if !dara.IsNil(request.RemarkSearchCondition) {
12628 query["RemarkSearchCondition"] = request.RemarkSearchCondition
12629 }
12630
12631 if !dara.IsNil(request.Remarks) {
12632 query["Remarks"] = request.Remarks
12633 }
12634
12635 if !dara.IsNil(request.Type) {
12636 query["Type"] = request.Type
12637 }
12638
12639 req := &openapiutil.OpenApiRequest{
12640 Query: openapiutil.Query(query),
12641 }
12642 params := &openapiutil.Params{
12643 Action: dara.String("SearchCloudGtmAddresses"),
12644 Version: dara.String("2015-01-09"),
12645 Protocol: dara.String("HTTPS"),
12646 Pathname: dara.String("/"),
12647 Method: dara.String("POST"),
12648 AuthType: dara.String("AK"),
12649 Style: dara.String("RPC"),
12650 ReqBodyType: dara.String("formData"),
12651 BodyType: dara.String("json"),
12652 }
12653 _result = &SearchCloudGtmAddressesResponse{}
12654 _body, _err := client.CallApi(params, req, runtime)
12655 if _err != nil {
12656 return _result, _err
12657 }
12658 _err = dara.Convert(_body, &_result)
12659 return _result, _err
12660 }
12661
12662 // Summary:
12663 //
12664 // Queries a list of addresses based on address names, descriptions, health check templates referenced by the addresses, or address IDs.
12665 //
12666 // @param request - SearchCloudGtmAddressesRequest
12667 //
12668 // @return SearchCloudGtmAddressesResponse
12669 func SearchCloudGtmAddresses(client *Client, request *SearchCloudGtmAddressesRequest) (_result *SearchCloudGtmAddressesResponse, _err error) {
12670 runtime := &dara.RuntimeOptions{}
12671 _result = &SearchCloudGtmAddressesResponse{}
12672 _body, _err := SearchCloudGtmAddressesWithOptions(client,request, runtime)
12673 if _err != nil {
12674 return _result, _err
12675 }
12676 _result = _body
12677 return _result, _err
12678 }
12679
12680 // Summary:
12681 //
12682 // Queries the configurations of an access domain name.
12683 //
12684 // @param request - SearchCloudGtmInstanceConfigsRequest
12685 //
12686 // @param runtime - runtime options for this request RuntimeOptions
12687 //
12688 // @return SearchCloudGtmInstanceConfigsResponse
12689 func SearchCloudGtmInstanceConfigsWithOptions(client *Client, request *SearchCloudGtmInstanceConfigsRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmInstanceConfigsResponse, _err error) {
12690 if dara.BoolValue(client.EnableValidate) == true {
12691 _err = request.Validate()
12692 if _err != nil {
12693 return _result, _err
12694 }
12695 }
12696 query := map[string]interface{}{}
12697 if !dara.IsNil(request.AcceptLanguage) {
12698 query["AcceptLanguage"] = request.AcceptLanguage
12699 }
12700
12701 if !dara.IsNil(request.AvailableStatus) {
12702 query["AvailableStatus"] = request.AvailableStatus
12703 }
12704
12705 if !dara.IsNil(request.ClientToken) {
12706 query["ClientToken"] = request.ClientToken
12707 }
12708
12709 if !dara.IsNil(request.EnableStatus) {
12710 query["EnableStatus"] = request.EnableStatus
12711 }
12712
12713 if !dara.IsNil(request.HealthStatus) {
12714 query["HealthStatus"] = request.HealthStatus
12715 }
12716
12717 if !dara.IsNil(request.InstanceId) {
12718 query["InstanceId"] = request.InstanceId
12719 }
12720
12721 if !dara.IsNil(request.PageNumber) {
12722 query["PageNumber"] = request.PageNumber
12723 }
12724
12725 if !dara.IsNil(request.PageSize) {
12726 query["PageSize"] = request.PageSize
12727 }
12728
12729 if !dara.IsNil(request.Remark) {
12730 query["Remark"] = request.Remark
12731 }
12732
12733 if !dara.IsNil(request.ScheduleDomainName) {
12734 query["ScheduleDomainName"] = request.ScheduleDomainName
12735 }
12736
12737 if !dara.IsNil(request.ScheduleZoneName) {
12738 query["ScheduleZoneName"] = request.ScheduleZoneName
12739 }
12740
12741 req := &openapiutil.OpenApiRequest{
12742 Query: openapiutil.Query(query),
12743 }
12744 params := &openapiutil.Params{
12745 Action: dara.String("SearchCloudGtmInstanceConfigs"),
12746 Version: dara.String("2015-01-09"),
12747 Protocol: dara.String("HTTPS"),
12748 Pathname: dara.String("/"),
12749 Method: dara.String("POST"),
12750 AuthType: dara.String("AK"),
12751 Style: dara.String("RPC"),
12752 ReqBodyType: dara.String("formData"),
12753 BodyType: dara.String("json"),
12754 }
12755 _result = &SearchCloudGtmInstanceConfigsResponse{}
12756 _body, _err := client.CallApi(params, req, runtime)
12757 if _err != nil {
12758 return _result, _err
12759 }
12760 _err = dara.Convert(_body, &_result)
12761 return _result, _err
12762 }
12763
12764 // Summary:
12765 //
12766 // Queries the configurations of an access domain name.
12767 //
12768 // @param request - SearchCloudGtmInstanceConfigsRequest
12769 //
12770 // @return SearchCloudGtmInstanceConfigsResponse
12771 func SearchCloudGtmInstanceConfigs(client *Client, request *SearchCloudGtmInstanceConfigsRequest) (_result *SearchCloudGtmInstanceConfigsResponse, _err error) {
12772 runtime := &dara.RuntimeOptions{}
12773 _result = &SearchCloudGtmInstanceConfigsResponse{}
12774 _body, _err := SearchCloudGtmInstanceConfigsWithOptions(client,request, runtime)
12775 if _err != nil {
12776 return _result, _err
12777 }
12778 _result = _body
12779 return _result, _err
12780 }
12781
12782 // Summary:
12783 //
12784 // Queries a list of instances.
12785 //
12786 // @param request - SearchCloudGtmInstancesRequest
12787 //
12788 // @param runtime - runtime options for this request RuntimeOptions
12789 //
12790 // @return SearchCloudGtmInstancesResponse
12791 func SearchCloudGtmInstancesWithOptions(client *Client, request *SearchCloudGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmInstancesResponse, _err error) {
12792 if dara.BoolValue(client.EnableValidate) == true {
12793 _err = request.Validate()
12794 if _err != nil {
12795 return _result, _err
12796 }
12797 }
12798 query := map[string]interface{}{}
12799 if !dara.IsNil(request.AcceptLanguage) {
12800 query["AcceptLanguage"] = request.AcceptLanguage
12801 }
12802
12803 if !dara.IsNil(request.ChargeType) {
12804 query["ChargeType"] = request.ChargeType
12805 }
12806
12807 if !dara.IsNil(request.ClientToken) {
12808 query["ClientToken"] = request.ClientToken
12809 }
12810
12811 if !dara.IsNil(request.InstanceId) {
12812 query["InstanceId"] = request.InstanceId
12813 }
12814
12815 if !dara.IsNil(request.InstanceName) {
12816 query["InstanceName"] = request.InstanceName
12817 }
12818
12819 if !dara.IsNil(request.PageNumber) {
12820 query["PageNumber"] = request.PageNumber
12821 }
12822
12823 if !dara.IsNil(request.PageSize) {
12824 query["PageSize"] = request.PageSize
12825 }
12826
12827 req := &openapiutil.OpenApiRequest{
12828 Query: openapiutil.Query(query),
12829 }
12830 params := &openapiutil.Params{
12831 Action: dara.String("SearchCloudGtmInstances"),
12832 Version: dara.String("2015-01-09"),
12833 Protocol: dara.String("HTTPS"),
12834 Pathname: dara.String("/"),
12835 Method: dara.String("POST"),
12836 AuthType: dara.String("AK"),
12837 Style: dara.String("RPC"),
12838 ReqBodyType: dara.String("formData"),
12839 BodyType: dara.String("json"),
12840 }
12841 _result = &SearchCloudGtmInstancesResponse{}
12842 _body, _err := client.CallApi(params, req, runtime)
12843 if _err != nil {
12844 return _result, _err
12845 }
12846 _err = dara.Convert(_body, &_result)
12847 return _result, _err
12848 }
12849
12850 // Summary:
12851 //
12852 // Queries a list of instances.
12853 //
12854 // @param request - SearchCloudGtmInstancesRequest
12855 //
12856 // @return SearchCloudGtmInstancesResponse
12857 func SearchCloudGtmInstances(client *Client, request *SearchCloudGtmInstancesRequest) (_result *SearchCloudGtmInstancesResponse, _err error) {
12858 runtime := &dara.RuntimeOptions{}
12859 _result = &SearchCloudGtmInstancesResponse{}
12860 _body, _err := SearchCloudGtmInstancesWithOptions(client,request, runtime)
12861 if _err != nil {
12862 return _result, _err
12863 }
12864 _result = _body
12865 return _result, _err
12866 }
12867
12868 // Summary:
12869 //
12870 // Queries the list of health check templates.
12871 //
12872 // @param request - SearchCloudGtmMonitorTemplatesRequest
12873 //
12874 // @param runtime - runtime options for this request RuntimeOptions
12875 //
12876 // @return SearchCloudGtmMonitorTemplatesResponse
12877 func SearchCloudGtmMonitorTemplatesWithOptions(client *Client, request *SearchCloudGtmMonitorTemplatesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmMonitorTemplatesResponse, _err error) {
12878 if dara.BoolValue(client.EnableValidate) == true {
12879 _err = request.Validate()
12880 if _err != nil {
12881 return _result, _err
12882 }
12883 }
12884 query := map[string]interface{}{}
12885 if !dara.IsNil(request.AcceptLanguage) {
12886 query["AcceptLanguage"] = request.AcceptLanguage
12887 }
12888
12889 if !dara.IsNil(request.IpVersion) {
12890 query["IpVersion"] = request.IpVersion
12891 }
12892
12893 if !dara.IsNil(request.Name) {
12894 query["Name"] = request.Name
12895 }
12896
12897 if !dara.IsNil(request.PageNumber) {
12898 query["PageNumber"] = request.PageNumber
12899 }
12900
12901 if !dara.IsNil(request.PageSize) {
12902 query["PageSize"] = request.PageSize
12903 }
12904
12905 if !dara.IsNil(request.Protocol) {
12906 query["Protocol"] = request.Protocol
12907 }
12908
12909 req := &openapiutil.OpenApiRequest{
12910 Query: openapiutil.Query(query),
12911 }
12912 params := &openapiutil.Params{
12913 Action: dara.String("SearchCloudGtmMonitorTemplates"),
12914 Version: dara.String("2015-01-09"),
12915 Protocol: dara.String("HTTPS"),
12916 Pathname: dara.String("/"),
12917 Method: dara.String("POST"),
12918 AuthType: dara.String("AK"),
12919 Style: dara.String("RPC"),
12920 ReqBodyType: dara.String("formData"),
12921 BodyType: dara.String("json"),
12922 }
12923 _result = &SearchCloudGtmMonitorTemplatesResponse{}
12924 _body, _err := client.CallApi(params, req, runtime)
12925 if _err != nil {
12926 return _result, _err
12927 }
12928 _err = dara.Convert(_body, &_result)
12929 return _result, _err
12930 }
12931
12932 // Summary:
12933 //
12934 // Queries the list of health check templates.
12935 //
12936 // @param request - SearchCloudGtmMonitorTemplatesRequest
12937 //
12938 // @return SearchCloudGtmMonitorTemplatesResponse
12939 func SearchCloudGtmMonitorTemplates(client *Client, request *SearchCloudGtmMonitorTemplatesRequest) (_result *SearchCloudGtmMonitorTemplatesResponse, _err error) {
12940 runtime := &dara.RuntimeOptions{}
12941 _result = &SearchCloudGtmMonitorTemplatesResponse{}
12942 _body, _err := SearchCloudGtmMonitorTemplatesWithOptions(client,request, runtime)
12943 if _err != nil {
12944 return _result, _err
12945 }
12946 _result = _body
12947 return _result, _err
12948 }
12949
12950 // Summary:
12951 //
12952 // 搜索递归解析内置权威解析记录
12953 //
12954 // @param request - SearchRecursionRecordsRequest
12955 //
12956 // @param runtime - runtime options for this request RuntimeOptions
12957 //
12958 // @return SearchRecursionRecordsResponse
12959 func SearchRecursionRecordsWithOptions(client *Client, request *SearchRecursionRecordsRequest, runtime *dara.RuntimeOptions) (_result *SearchRecursionRecordsResponse, _err error) {
12960 if dara.BoolValue(client.EnableValidate) == true {
12961 _err = request.Validate()
12962 if _err != nil {
12963 return _result, _err
12964 }
12965 }
12966 query := map[string]interface{}{}
12967 if !dara.IsNil(request.Direction) {
12968 query["Direction"] = request.Direction
12969 }
12970
12971 if !dara.IsNil(request.EnableStatus) {
12972 query["EnableStatus"] = request.EnableStatus
12973 }
12974
12975 if !dara.IsNil(request.MaxResults) {
12976 query["MaxResults"] = request.MaxResults
12977 }
12978
12979 if !dara.IsNil(request.NextToken) {
12980 query["NextToken"] = request.NextToken
12981 }
12982
12983 if !dara.IsNil(request.OrderBy) {
12984 query["OrderBy"] = request.OrderBy
12985 }
12986
12987 if !dara.IsNil(request.PageNumber) {
12988 query["PageNumber"] = request.PageNumber
12989 }
12990
12991 if !dara.IsNil(request.PageSize) {
12992 query["PageSize"] = request.PageSize
12993 }
12994
12995 if !dara.IsNil(request.Remark) {
12996 query["Remark"] = request.Remark
12997 }
12998
12999 if !dara.IsNil(request.RequestSource) {
13000 query["RequestSource"] = request.RequestSource
13001 }
13002
13003 if !dara.IsNil(request.Rr) {
13004 query["Rr"] = request.Rr
13005 }
13006
13007 if !dara.IsNil(request.Ttl) {
13008 query["Ttl"] = request.Ttl
13009 }
13010
13011 if !dara.IsNil(request.Type) {
13012 query["Type"] = request.Type
13013 }
13014
13015 if !dara.IsNil(request.Value) {
13016 query["Value"] = request.Value
13017 }
13018
13019 if !dara.IsNil(request.Weight) {
13020 query["Weight"] = request.Weight
13021 }
13022
13023 if !dara.IsNil(request.ZoneId) {
13024 query["ZoneId"] = request.ZoneId
13025 }
13026
13027 req := &openapiutil.OpenApiRequest{
13028 Query: openapiutil.Query(query),
13029 }
13030 params := &openapiutil.Params{
13031 Action: dara.String("SearchRecursionRecords"),
13032 Version: dara.String("2015-01-09"),
13033 Protocol: dara.String("HTTPS"),
13034 Pathname: dara.String("/"),
13035 Method: dara.String("POST"),
13036 AuthType: dara.String("AK"),
13037 Style: dara.String("RPC"),
13038 ReqBodyType: dara.String("formData"),
13039 BodyType: dara.String("json"),
13040 }
13041 _result = &SearchRecursionRecordsResponse{}
13042 _body, _err := client.CallApi(params, req, runtime)
13043 if _err != nil {
13044 return _result, _err
13045 }
13046 _err = dara.Convert(_body, &_result)
13047 return _result, _err
13048 }
13049
13050 // Summary:
13051 //
13052 // 搜索递归解析内置权威解析记录
13053 //
13054 // @param request - SearchRecursionRecordsRequest
13055 //
13056 // @return SearchRecursionRecordsResponse
13057 func SearchRecursionRecords(client *Client, request *SearchRecursionRecordsRequest) (_result *SearchRecursionRecordsResponse, _err error) {
13058 runtime := &dara.RuntimeOptions{}
13059 _result = &SearchRecursionRecordsResponse{}
13060 _body, _err := SearchRecursionRecordsWithOptions(client,request, runtime)
13061 if _err != nil {
13062 return _result, _err
13063 }
13064 _result = _body
13065 return _result, _err
13066 }
13067
13068 // Summary:
13069 //
13070 // 搜索递归解析内置权威域名zone
13071 //
13072 // @param tmpReq - SearchRecursionZonesRequest
13073 //
13074 // @param runtime - runtime options for this request RuntimeOptions
13075 //
13076 // @return SearchRecursionZonesResponse
13077 func SearchRecursionZonesWithOptions(client *Client, tmpReq *SearchRecursionZonesRequest, runtime *dara.RuntimeOptions) (_result *SearchRecursionZonesResponse, _err error) {
13078 if dara.BoolValue(client.EnableValidate) == true {
13079 _err = tmpReq.Validate()
13080 if _err != nil {
13081 return _result, _err
13082 }
13083 }
13084 request := &SearchRecursionZonesShrinkRequest{}
13085 openapiutil.Convert(tmpReq, request)
13086 if !dara.IsNil(tmpReq.EffectiveScopes) {
13087 request.EffectiveScopesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.EffectiveScopes, dara.String("EffectiveScopes"), dara.String("json"))
13088 }
13089
13090 query := map[string]interface{}{}
13091 if !dara.IsNil(request.Direction) {
13092 query["Direction"] = request.Direction
13093 }
13094
13095 if !dara.IsNil(request.EffectiveScopesShrink) {
13096 query["EffectiveScopes"] = request.EffectiveScopesShrink
13097 }
13098
13099 if !dara.IsNil(request.MaxResults) {
13100 query["MaxResults"] = request.MaxResults
13101 }
13102
13103 if !dara.IsNil(request.NextToken) {
13104 query["NextToken"] = request.NextToken
13105 }
13106
13107 if !dara.IsNil(request.OrderBy) {
13108 query["OrderBy"] = request.OrderBy
13109 }
13110
13111 if !dara.IsNil(request.PageNumber) {
13112 query["PageNumber"] = request.PageNumber
13113 }
13114
13115 if !dara.IsNil(request.PageSize) {
13116 query["PageSize"] = request.PageSize
13117 }
13118
13119 if !dara.IsNil(request.Remark) {
13120 query["Remark"] = request.Remark
13121 }
13122
13123 if !dara.IsNil(request.ZoneName) {
13124 query["ZoneName"] = request.ZoneName
13125 }
13126
13127 req := &openapiutil.OpenApiRequest{
13128 Query: openapiutil.Query(query),
13129 }
13130 params := &openapiutil.Params{
13131 Action: dara.String("SearchRecursionZones"),
13132 Version: dara.String("2015-01-09"),
13133 Protocol: dara.String("HTTPS"),
13134 Pathname: dara.String("/"),
13135 Method: dara.String("POST"),
13136 AuthType: dara.String("AK"),
13137 Style: dara.String("RPC"),
13138 ReqBodyType: dara.String("formData"),
13139 BodyType: dara.String("json"),
13140 }
13141 _result = &SearchRecursionZonesResponse{}
13142 _body, _err := client.CallApi(params, req, runtime)
13143 if _err != nil {
13144 return _result, _err
13145 }
13146 _err = dara.Convert(_body, &_result)
13147 return _result, _err
13148 }
13149
13150 // Summary:
13151 //
13152 // 搜索递归解析内置权威域名zone
13153 //
13154 // @param request - SearchRecursionZonesRequest
13155 //
13156 // @return SearchRecursionZonesResponse
13157 func SearchRecursionZones(client *Client, request *SearchRecursionZonesRequest) (_result *SearchRecursionZonesResponse, _err error) {
13158 runtime := &dara.RuntimeOptions{}
13159 _result = &SearchRecursionZonesResponse{}
13160 _body, _err := SearchRecursionZonesWithOptions(client,request, runtime)
13161 if _err != nil {
13162 return _result, _err
13163 }
13164 _result = _body
13165 return _result, _err
13166 }
13167
13168 // Summary:
13169 //
13170 // Enables or disables weighted round-robin based on the specified parameters.
13171 //
13172 // @param request - SetDNSSLBStatusRequest
13173 //
13174 // @param runtime - runtime options for this request RuntimeOptions
13175 //
13176 // @return SetDNSSLBStatusResponse
13177 func SetDNSSLBStatusWithOptions(client *Client, request *SetDNSSLBStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDNSSLBStatusResponse, _err error) {
13178 if dara.BoolValue(client.EnableValidate) == true {
13179 _err = request.Validate()
13180 if _err != nil {
13181 return _result, _err
13182 }
13183 }
13184 query := map[string]interface{}{}
13185 if !dara.IsNil(request.DomainName) {
13186 query["DomainName"] = request.DomainName
13187 }
13188
13189 if !dara.IsNil(request.Lang) {
13190 query["Lang"] = request.Lang
13191 }
13192
13193 if !dara.IsNil(request.Line) {
13194 query["Line"] = request.Line
13195 }
13196
13197 if !dara.IsNil(request.Open) {
13198 query["Open"] = request.Open
13199 }
13200
13201 if !dara.IsNil(request.SubDomain) {
13202 query["SubDomain"] = request.SubDomain
13203 }
13204
13205 if !dara.IsNil(request.Type) {
13206 query["Type"] = request.Type
13207 }
13208
13209 if !dara.IsNil(request.UserClientIp) {
13210 query["UserClientIp"] = request.UserClientIp
13211 }
13212
13213 req := &openapiutil.OpenApiRequest{
13214 Query: openapiutil.Query(query),
13215 }
13216 params := &openapiutil.Params{
13217 Action: dara.String("SetDNSSLBStatus"),
13218 Version: dara.String("2015-01-09"),
13219 Protocol: dara.String("HTTPS"),
13220 Pathname: dara.String("/"),
13221 Method: dara.String("POST"),
13222 AuthType: dara.String("AK"),
13223 Style: dara.String("RPC"),
13224 ReqBodyType: dara.String("formData"),
13225 BodyType: dara.String("json"),
13226 }
13227 _result = &SetDNSSLBStatusResponse{}
13228 _body, _err := client.CallApi(params, req, runtime)
13229 if _err != nil {
13230 return _result, _err
13231 }
13232 _err = dara.Convert(_body, &_result)
13233 return _result, _err
13234 }
13235
13236 // Summary:
13237 //
13238 // Enables or disables weighted round-robin based on the specified parameters.
13239 //
13240 // @param request - SetDNSSLBStatusRequest
13241 //
13242 // @return SetDNSSLBStatusResponse
13243 func SetDNSSLBStatus(client *Client, request *SetDNSSLBStatusRequest) (_result *SetDNSSLBStatusResponse, _err error) {
13244 runtime := &dara.RuntimeOptions{}
13245 _result = &SetDNSSLBStatusResponse{}
13246 _body, _err := SetDNSSLBStatusWithOptions(client,request, runtime)
13247 if _err != nil {
13248 return _result, _err
13249 }
13250 _result = _body
13251 return _result, _err
13252 }
13253
13254 // Summary:
13255 //
13256 // Modifies an access policy.
13257 //
13258 // Description:
13259 //
13260 // ***
13261 //
13262 // @param request - SetDnsGtmAccessModeRequest
13263 //
13264 // @param runtime - runtime options for this request RuntimeOptions
13265 //
13266 // @return SetDnsGtmAccessModeResponse
13267 func SetDnsGtmAccessModeWithOptions(client *Client, request *SetDnsGtmAccessModeRequest, runtime *dara.RuntimeOptions) (_result *SetDnsGtmAccessModeResponse, _err error) {
13268 if dara.BoolValue(client.EnableValidate) == true {
13269 _err = request.Validate()
13270 if _err != nil {
13271 return _result, _err
13272 }
13273 }
13274 query := map[string]interface{}{}
13275 if !dara.IsNil(request.AccessMode) {
13276 query["AccessMode"] = request.AccessMode
13277 }
13278
13279 if !dara.IsNil(request.Lang) {
13280 query["Lang"] = request.Lang
13281 }
13282
13283 if !dara.IsNil(request.StrategyId) {
13284 query["StrategyId"] = request.StrategyId
13285 }
13286
13287 req := &openapiutil.OpenApiRequest{
13288 Query: openapiutil.Query(query),
13289 }
13290 params := &openapiutil.Params{
13291 Action: dara.String("SetDnsGtmAccessMode"),
13292 Version: dara.String("2015-01-09"),
13293 Protocol: dara.String("HTTPS"),
13294 Pathname: dara.String("/"),
13295 Method: dara.String("POST"),
13296 AuthType: dara.String("AK"),
13297 Style: dara.String("RPC"),
13298 ReqBodyType: dara.String("formData"),
13299 BodyType: dara.String("json"),
13300 }
13301 _result = &SetDnsGtmAccessModeResponse{}
13302 _body, _err := client.CallApi(params, req, runtime)
13303 if _err != nil {
13304 return _result, _err
13305 }
13306 _err = dara.Convert(_body, &_result)
13307 return _result, _err
13308 }
13309
13310 // Summary:
13311 //
13312 // Modifies an access policy.
13313 //
13314 // Description:
13315 //
13316 // ***
13317 //
13318 // @param request - SetDnsGtmAccessModeRequest
13319 //
13320 // @return SetDnsGtmAccessModeResponse
13321 func SetDnsGtmAccessMode(client *Client, request *SetDnsGtmAccessModeRequest) (_result *SetDnsGtmAccessModeResponse, _err error) {
13322 runtime := &dara.RuntimeOptions{}
13323 _result = &SetDnsGtmAccessModeResponse{}
13324 _body, _err := SetDnsGtmAccessModeWithOptions(client,request, runtime)
13325 if _err != nil {
13326 return _result, _err
13327 }
13328 _result = _body
13329 return _result, _err
13330 }
13331
13332 // Summary:
13333 //
13334 // Specifies the health check status of an address pool.
13335 //
13336 // @param request - SetDnsGtmMonitorStatusRequest
13337 //
13338 // @param runtime - runtime options for this request RuntimeOptions
13339 //
13340 // @return SetDnsGtmMonitorStatusResponse
13341 func SetDnsGtmMonitorStatusWithOptions(client *Client, request *SetDnsGtmMonitorStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDnsGtmMonitorStatusResponse, _err error) {
13342 if dara.BoolValue(client.EnableValidate) == true {
13343 _err = request.Validate()
13344 if _err != nil {
13345 return _result, _err
13346 }
13347 }
13348 query := map[string]interface{}{}
13349 if !dara.IsNil(request.Lang) {
13350 query["Lang"] = request.Lang
13351 }
13352
13353 if !dara.IsNil(request.MonitorConfigId) {
13354 query["MonitorConfigId"] = request.MonitorConfigId
13355 }
13356
13357 if !dara.IsNil(request.Status) {
13358 query["Status"] = request.Status
13359 }
13360
13361 req := &openapiutil.OpenApiRequest{
13362 Query: openapiutil.Query(query),
13363 }
13364 params := &openapiutil.Params{
13365 Action: dara.String("SetDnsGtmMonitorStatus"),
13366 Version: dara.String("2015-01-09"),
13367 Protocol: dara.String("HTTPS"),
13368 Pathname: dara.String("/"),
13369 Method: dara.String("POST"),
13370 AuthType: dara.String("AK"),
13371 Style: dara.String("RPC"),
13372 ReqBodyType: dara.String("formData"),
13373 BodyType: dara.String("json"),
13374 }
13375 _result = &SetDnsGtmMonitorStatusResponse{}
13376 _body, _err := client.CallApi(params, req, runtime)
13377 if _err != nil {
13378 return _result, _err
13379 }
13380 _err = dara.Convert(_body, &_result)
13381 return _result, _err
13382 }
13383
13384 // Summary:
13385 //
13386 // Specifies the health check status of an address pool.
13387 //
13388 // @param request - SetDnsGtmMonitorStatusRequest
13389 //
13390 // @return SetDnsGtmMonitorStatusResponse
13391 func SetDnsGtmMonitorStatus(client *Client, request *SetDnsGtmMonitorStatusRequest) (_result *SetDnsGtmMonitorStatusResponse, _err error) {
13392 runtime := &dara.RuntimeOptions{}
13393 _result = &SetDnsGtmMonitorStatusResponse{}
13394 _body, _err := SetDnsGtmMonitorStatusWithOptions(client,request, runtime)
13395 if _err != nil {
13396 return _result, _err
13397 }
13398 _result = _body
13399 return _result, _err
13400 }
13401
13402 // Summary:
13403 //
13404 // Enables or disables the Domain Name System Security Extensions (DNSSEC) for a domain name. This feature is available only for the users of the paid editions of Alibaba Cloud DNS.
13405 //
13406 // @param request - SetDomainDnssecStatusRequest
13407 //
13408 // @param runtime - runtime options for this request RuntimeOptions
13409 //
13410 // @return SetDomainDnssecStatusResponse
13411 func SetDomainDnssecStatusWithOptions(client *Client, request *SetDomainDnssecStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDomainDnssecStatusResponse, _err error) {
13412 if dara.BoolValue(client.EnableValidate) == true {
13413 _err = request.Validate()
13414 if _err != nil {
13415 return _result, _err
13416 }
13417 }
13418 query := map[string]interface{}{}
13419 if !dara.IsNil(request.DomainName) {
13420 query["DomainName"] = request.DomainName
13421 }
13422
13423 if !dara.IsNil(request.Lang) {
13424 query["Lang"] = request.Lang
13425 }
13426
13427 if !dara.IsNil(request.Status) {
13428 query["Status"] = request.Status
13429 }
13430
13431 req := &openapiutil.OpenApiRequest{
13432 Query: openapiutil.Query(query),
13433 }
13434 params := &openapiutil.Params{
13435 Action: dara.String("SetDomainDnssecStatus"),
13436 Version: dara.String("2015-01-09"),
13437 Protocol: dara.String("HTTPS"),
13438 Pathname: dara.String("/"),
13439 Method: dara.String("POST"),
13440 AuthType: dara.String("AK"),
13441 Style: dara.String("RPC"),
13442 ReqBodyType: dara.String("formData"),
13443 BodyType: dara.String("json"),
13444 }
13445 _result = &SetDomainDnssecStatusResponse{}
13446 _body, _err := client.CallApi(params, req, runtime)
13447 if _err != nil {
13448 return _result, _err
13449 }
13450 _err = dara.Convert(_body, &_result)
13451 return _result, _err
13452 }
13453
13454 // Summary:
13455 //
13456 // Enables or disables the Domain Name System Security Extensions (DNSSEC) for a domain name. This feature is available only for the users of the paid editions of Alibaba Cloud DNS.
13457 //
13458 // @param request - SetDomainDnssecStatusRequest
13459 //
13460 // @return SetDomainDnssecStatusResponse
13461 func SetDomainDnssecStatus(client *Client, request *SetDomainDnssecStatusRequest) (_result *SetDomainDnssecStatusResponse, _err error) {
13462 runtime := &dara.RuntimeOptions{}
13463 _result = &SetDomainDnssecStatusResponse{}
13464 _body, _err := SetDomainDnssecStatusWithOptions(client,request, runtime)
13465 if _err != nil {
13466 return _result, _err
13467 }
13468 _result = _body
13469 return _result, _err
13470 }
13471
13472 // Summary:
13473 //
13474 // Specifies the status of an Alibaba Cloud DNS (DNS) record based on the specified parameters.
13475 //
13476 // @param request - SetDomainRecordStatusRequest
13477 //
13478 // @param runtime - runtime options for this request RuntimeOptions
13479 //
13480 // @return SetDomainRecordStatusResponse
13481 func SetDomainRecordStatusWithOptions(client *Client, request *SetDomainRecordStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDomainRecordStatusResponse, _err error) {
13482 if dara.BoolValue(client.EnableValidate) == true {
13483 _err = request.Validate()
13484 if _err != nil {
13485 return _result, _err
13486 }
13487 }
13488 query := map[string]interface{}{}
13489 if !dara.IsNil(request.Lang) {
13490 query["Lang"] = request.Lang
13491 }
13492
13493 if !dara.IsNil(request.RecordId) {
13494 query["RecordId"] = request.RecordId
13495 }
13496
13497 if !dara.IsNil(request.Status) {
13498 query["Status"] = request.Status
13499 }
13500
13501 if !dara.IsNil(request.UserClientIp) {
13502 query["UserClientIp"] = request.UserClientIp
13503 }
13504
13505 req := &openapiutil.OpenApiRequest{
13506 Query: openapiutil.Query(query),
13507 }
13508 params := &openapiutil.Params{
13509 Action: dara.String("SetDomainRecordStatus"),
13510 Version: dara.String("2015-01-09"),
13511 Protocol: dara.String("HTTPS"),
13512 Pathname: dara.String("/"),
13513 Method: dara.String("POST"),
13514 AuthType: dara.String("AK"),
13515 Style: dara.String("RPC"),
13516 ReqBodyType: dara.String("formData"),
13517 BodyType: dara.String("json"),
13518 }
13519 _result = &SetDomainRecordStatusResponse{}
13520 _body, _err := client.CallApi(params, req, runtime)
13521 if _err != nil {
13522 return _result, _err
13523 }
13524 _err = dara.Convert(_body, &_result)
13525 return _result, _err
13526 }
13527
13528 // Summary:
13529 //
13530 // Specifies the status of an Alibaba Cloud DNS (DNS) record based on the specified parameters.
13531 //
13532 // @param request - SetDomainRecordStatusRequest
13533 //
13534 // @return SetDomainRecordStatusResponse
13535 func SetDomainRecordStatus(client *Client, request *SetDomainRecordStatusRequest) (_result *SetDomainRecordStatusResponse, _err error) {
13536 runtime := &dara.RuntimeOptions{}
13537 _result = &SetDomainRecordStatusResponse{}
13538 _body, _err := SetDomainRecordStatusWithOptions(client,request, runtime)
13539 if _err != nil {
13540 return _result, _err
13541 }
13542 _result = _body
13543 return _result, _err
13544 }
13545
13546 // Summary:
13547 //
13548 // Modifies a policy for switchover between address pool sets.
13549 //
13550 // @param request - SetGtmAccessModeRequest
13551 //
13552 // @param runtime - runtime options for this request RuntimeOptions
13553 //
13554 // @return SetGtmAccessModeResponse
13555 func SetGtmAccessModeWithOptions(client *Client, request *SetGtmAccessModeRequest, runtime *dara.RuntimeOptions) (_result *SetGtmAccessModeResponse, _err error) {
13556 if dara.BoolValue(client.EnableValidate) == true {
13557 _err = request.Validate()
13558 if _err != nil {
13559 return _result, _err
13560 }
13561 }
13562 query := map[string]interface{}{}
13563 if !dara.IsNil(request.AccessMode) {
13564 query["AccessMode"] = request.AccessMode
13565 }
13566
13567 if !dara.IsNil(request.Lang) {
13568 query["Lang"] = request.Lang
13569 }
13570
13571 if !dara.IsNil(request.StrategyId) {
13572 query["StrategyId"] = request.StrategyId
13573 }
13574
13575 req := &openapiutil.OpenApiRequest{
13576 Query: openapiutil.Query(query),
13577 }
13578 params := &openapiutil.Params{
13579 Action: dara.String("SetGtmAccessMode"),
13580 Version: dara.String("2015-01-09"),
13581 Protocol: dara.String("HTTPS"),
13582 Pathname: dara.String("/"),
13583 Method: dara.String("POST"),
13584 AuthType: dara.String("AK"),
13585 Style: dara.String("RPC"),
13586 ReqBodyType: dara.String("formData"),
13587 BodyType: dara.String("json"),
13588 }
13589 _result = &SetGtmAccessModeResponse{}
13590 _body, _err := client.CallApi(params, req, runtime)
13591 if _err != nil {
13592 return _result, _err
13593 }
13594 _err = dara.Convert(_body, &_result)
13595 return _result, _err
13596 }
13597
13598 // Summary:
13599 //
13600 // Modifies a policy for switchover between address pool sets.
13601 //
13602 // @param request - SetGtmAccessModeRequest
13603 //
13604 // @return SetGtmAccessModeResponse
13605 func SetGtmAccessMode(client *Client, request *SetGtmAccessModeRequest) (_result *SetGtmAccessModeResponse, _err error) {
13606 runtime := &dara.RuntimeOptions{}
13607 _result = &SetGtmAccessModeResponse{}
13608 _body, _err := SetGtmAccessModeWithOptions(client,request, runtime)
13609 if _err != nil {
13610 return _result, _err
13611 }
13612 _result = _body
13613 return _result, _err
13614 }
13615
13616 // @param request - SetGtmMonitorStatusRequest
13617 //
13618 // @param runtime - runtime options for this request RuntimeOptions
13619 //
13620 // @return SetGtmMonitorStatusResponse
13621 func SetGtmMonitorStatusWithOptions(client *Client, request *SetGtmMonitorStatusRequest, runtime *dara.RuntimeOptions) (_result *SetGtmMonitorStatusResponse, _err error) {
13622 if dara.BoolValue(client.EnableValidate) == true {
13623 _err = request.Validate()
13624 if _err != nil {
13625 return _result, _err
13626 }
13627 }
13628 query := map[string]interface{}{}
13629 if !dara.IsNil(request.Lang) {
13630 query["Lang"] = request.Lang
13631 }
13632
13633 if !dara.IsNil(request.MonitorConfigId) {
13634 query["MonitorConfigId"] = request.MonitorConfigId
13635 }
13636
13637 if !dara.IsNil(request.Status) {
13638 query["Status"] = request.Status
13639 }
13640
13641 req := &openapiutil.OpenApiRequest{
13642 Query: openapiutil.Query(query),
13643 }
13644 params := &openapiutil.Params{
13645 Action: dara.String("SetGtmMonitorStatus"),
13646 Version: dara.String("2015-01-09"),
13647 Protocol: dara.String("HTTPS"),
13648 Pathname: dara.String("/"),
13649 Method: dara.String("POST"),
13650 AuthType: dara.String("AK"),
13651 Style: dara.String("RPC"),
13652 ReqBodyType: dara.String("formData"),
13653 BodyType: dara.String("json"),
13654 }
13655 _result = &SetGtmMonitorStatusResponse{}
13656 _body, _err := client.CallApi(params, req, runtime)
13657 if _err != nil {
13658 return _result, _err
13659 }
13660 _err = dara.Convert(_body, &_result)
13661 return _result, _err
13662 }
13663
13664 // @param request - SetGtmMonitorStatusRequest
13665 //
13666 // @return SetGtmMonitorStatusResponse
13667 func SetGtmMonitorStatus(client *Client, request *SetGtmMonitorStatusRequest) (_result *SetGtmMonitorStatusResponse, _err error) {
13668 runtime := &dara.RuntimeOptions{}
13669 _result = &SetGtmMonitorStatusResponse{}
13670 _body, _err := SetGtmMonitorStatusWithOptions(client,request, runtime)
13671 if _err != nil {
13672 return _result, _err
13673 }
13674 _result = _body
13675 return _result, _err
13676 }
13677
13678 // Summary:
13679 //
13680 // 提交缓存刷新任务
13681 //
13682 // @param request - SubmitIspFlushCacheTaskRequest
13683 //
13684 // @param runtime - runtime options for this request RuntimeOptions
13685 //
13686 // @return SubmitIspFlushCacheTaskResponse
13687 func SubmitIspFlushCacheTaskWithOptions(client *Client, request *SubmitIspFlushCacheTaskRequest, runtime *dara.RuntimeOptions) (_result *SubmitIspFlushCacheTaskResponse, _err error) {
13688 if dara.BoolValue(client.EnableValidate) == true {
13689 _err = request.Validate()
13690 if _err != nil {
13691 return _result, _err
13692 }
13693 }
13694 query := map[string]interface{}{}
13695 if !dara.IsNil(request.ClientToken) {
13696 query["ClientToken"] = request.ClientToken
13697 }
13698
13699 if !dara.IsNil(request.DomainName) {
13700 query["DomainName"] = request.DomainName
13701 }
13702
13703 if !dara.IsNil(request.Isp) {
13704 query["Isp"] = request.Isp
13705 }
13706
13707 if !dara.IsNil(request.Lang) {
13708 query["Lang"] = request.Lang
13709 }
13710
13711 req := &openapiutil.OpenApiRequest{
13712 Query: openapiutil.Query(query),
13713 }
13714 params := &openapiutil.Params{
13715 Action: dara.String("SubmitIspFlushCacheTask"),
13716 Version: dara.String("2015-01-09"),
13717 Protocol: dara.String("HTTPS"),
13718 Pathname: dara.String("/"),
13719 Method: dara.String("POST"),
13720 AuthType: dara.String("AK"),
13721 Style: dara.String("RPC"),
13722 ReqBodyType: dara.String("formData"),
13723 BodyType: dara.String("json"),
13724 }
13725 _result = &SubmitIspFlushCacheTaskResponse{}
13726 _body, _err := client.CallApi(params, req, runtime)
13727 if _err != nil {
13728 return _result, _err
13729 }
13730 _err = dara.Convert(_body, &_result)
13731 return _result, _err
13732 }
13733
13734 // Summary:
13735 //
13736 // 提交缓存刷新任务
13737 //
13738 // @param request - SubmitIspFlushCacheTaskRequest
13739 //
13740 // @return SubmitIspFlushCacheTaskResponse
13741 func SubmitIspFlushCacheTask(client *Client, request *SubmitIspFlushCacheTaskRequest) (_result *SubmitIspFlushCacheTaskResponse, _err error) {
13742 runtime := &dara.RuntimeOptions{}
13743 _result = &SubmitIspFlushCacheTaskResponse{}
13744 _body, _err := SubmitIspFlushCacheTaskWithOptions(client,request, runtime)
13745 if _err != nil {
13746 return _result, _err
13747 }
13748 _result = _body
13749 return _result, _err
13750 }
13751
13752 // Summary:
13753 //
13754 // Changes the access policy type for a Global Traffic Manager (GTM) instance.
13755 //
13756 // @param request - SwitchDnsGtmInstanceStrategyModeRequest
13757 //
13758 // @param runtime - runtime options for this request RuntimeOptions
13759 //
13760 // @return SwitchDnsGtmInstanceStrategyModeResponse
13761 func SwitchDnsGtmInstanceStrategyModeWithOptions(client *Client, request *SwitchDnsGtmInstanceStrategyModeRequest, runtime *dara.RuntimeOptions) (_result *SwitchDnsGtmInstanceStrategyModeResponse, _err error) {
13762 if dara.BoolValue(client.EnableValidate) == true {
13763 _err = request.Validate()
13764 if _err != nil {
13765 return _result, _err
13766 }
13767 }
13768 query := map[string]interface{}{}
13769 if !dara.IsNil(request.InstanceId) {
13770 query["InstanceId"] = request.InstanceId
13771 }
13772
13773 if !dara.IsNil(request.Lang) {
13774 query["Lang"] = request.Lang
13775 }
13776
13777 if !dara.IsNil(request.StrategyMode) {
13778 query["StrategyMode"] = request.StrategyMode
13779 }
13780
13781 req := &openapiutil.OpenApiRequest{
13782 Query: openapiutil.Query(query),
13783 }
13784 params := &openapiutil.Params{
13785 Action: dara.String("SwitchDnsGtmInstanceStrategyMode"),
13786 Version: dara.String("2015-01-09"),
13787 Protocol: dara.String("HTTPS"),
13788 Pathname: dara.String("/"),
13789 Method: dara.String("POST"),
13790 AuthType: dara.String("AK"),
13791 Style: dara.String("RPC"),
13792 ReqBodyType: dara.String("formData"),
13793 BodyType: dara.String("json"),
13794 }
13795 _result = &SwitchDnsGtmInstanceStrategyModeResponse{}
13796 _body, _err := client.CallApi(params, req, runtime)
13797 if _err != nil {
13798 return _result, _err
13799 }
13800 _err = dara.Convert(_body, &_result)
13801 return _result, _err
13802 }
13803
13804 // Summary:
13805 //
13806 // Changes the access policy type for a Global Traffic Manager (GTM) instance.
13807 //
13808 // @param request - SwitchDnsGtmInstanceStrategyModeRequest
13809 //
13810 // @return SwitchDnsGtmInstanceStrategyModeResponse
13811 func SwitchDnsGtmInstanceStrategyMode(client *Client, request *SwitchDnsGtmInstanceStrategyModeRequest) (_result *SwitchDnsGtmInstanceStrategyModeResponse, _err error) {
13812 runtime := &dara.RuntimeOptions{}
13813 _result = &SwitchDnsGtmInstanceStrategyModeResponse{}
13814 _body, _err := SwitchDnsGtmInstanceStrategyModeWithOptions(client,request, runtime)
13815 if _err != nil {
13816 return _result, _err
13817 }
13818 _result = _body
13819 return _result, _err
13820 }
13821
13822 // Summary:
13823 //
13824 // Adds and modifies a tag for a resource.
13825 //
13826 // @param request - TagResourcesRequest
13827 //
13828 // @param runtime - runtime options for this request RuntimeOptions
13829 //
13830 // @return TagResourcesResponse
13831 func TagResourcesWithOptions(client *Client, request *TagResourcesRequest, runtime *dara.RuntimeOptions) (_result *TagResourcesResponse, _err error) {
13832 if dara.BoolValue(client.EnableValidate) == true {
13833 _err = request.Validate()
13834 if _err != nil {
13835 return _result, _err
13836 }
13837 }
13838 query := map[string]interface{}{}
13839 if !dara.IsNil(request.Lang) {
13840 query["Lang"] = request.Lang
13841 }
13842
13843 if !dara.IsNil(request.ResourceId) {
13844 query["ResourceId"] = request.ResourceId
13845 }
13846
13847 if !dara.IsNil(request.ResourceType) {
13848 query["ResourceType"] = request.ResourceType
13849 }
13850
13851 if !dara.IsNil(request.Tag) {
13852 query["Tag"] = request.Tag
13853 }
13854
13855 req := &openapiutil.OpenApiRequest{
13856 Query: openapiutil.Query(query),
13857 }
13858 params := &openapiutil.Params{
13859 Action: dara.String("TagResources"),
13860 Version: dara.String("2015-01-09"),
13861 Protocol: dara.String("HTTPS"),
13862 Pathname: dara.String("/"),
13863 Method: dara.String("POST"),
13864 AuthType: dara.String("AK"),
13865 Style: dara.String("RPC"),
13866 ReqBodyType: dara.String("formData"),
13867 BodyType: dara.String("json"),
13868 }
13869 _result = &TagResourcesResponse{}
13870 _body, _err := client.CallApi(params, req, runtime)
13871 if _err != nil {
13872 return _result, _err
13873 }
13874 _err = dara.Convert(_body, &_result)
13875 return _result, _err
13876 }
13877
13878 // Summary:
13879 //
13880 // Adds and modifies a tag for a resource.
13881 //
13882 // @param request - TagResourcesRequest
13883 //
13884 // @return TagResourcesResponse
13885 func TagResources(client *Client, request *TagResourcesRequest) (_result *TagResourcesResponse, _err error) {
13886 runtime := &dara.RuntimeOptions{}
13887 _result = &TagResourcesResponse{}
13888 _body, _err := TagResourcesWithOptions(client,request, runtime)
13889 if _err != nil {
13890 return _result, _err
13891 }
13892 _result = _body
13893 return _result, _err
13894 }
13895
13896 // Summary:
13897 //
13898 // Transfers multiple domain names from the current account to another account at a time.
13899 //
13900 // @param request - TransferDomainRequest
13901 //
13902 // @param runtime - runtime options for this request RuntimeOptions
13903 //
13904 // @return TransferDomainResponse
13905 func TransferDomainWithOptions(client *Client, request *TransferDomainRequest, runtime *dara.RuntimeOptions) (_result *TransferDomainResponse, _err error) {
13906 if dara.BoolValue(client.EnableValidate) == true {
13907 _err = request.Validate()
13908 if _err != nil {
13909 return _result, _err
13910 }
13911 }
13912 query := map[string]interface{}{}
13913 if !dara.IsNil(request.DomainNames) {
13914 query["DomainNames"] = request.DomainNames
13915 }
13916
13917 if !dara.IsNil(request.Lang) {
13918 query["Lang"] = request.Lang
13919 }
13920
13921 if !dara.IsNil(request.Remark) {
13922 query["Remark"] = request.Remark
13923 }
13924
13925 if !dara.IsNil(request.TargetUserId) {
13926 query["TargetUserId"] = request.TargetUserId
13927 }
13928
13929 req := &openapiutil.OpenApiRequest{
13930 Query: openapiutil.Query(query),
13931 }
13932 params := &openapiutil.Params{
13933 Action: dara.String("TransferDomain"),
13934 Version: dara.String("2015-01-09"),
13935 Protocol: dara.String("HTTPS"),
13936 Pathname: dara.String("/"),
13937 Method: dara.String("POST"),
13938 AuthType: dara.String("AK"),
13939 Style: dara.String("RPC"),
13940 ReqBodyType: dara.String("formData"),
13941 BodyType: dara.String("json"),
13942 }
13943 _result = &TransferDomainResponse{}
13944 _body, _err := client.CallApi(params, req, runtime)
13945 if _err != nil {
13946 return _result, _err
13947 }
13948 _err = dara.Convert(_body, &_result)
13949 return _result, _err
13950 }
13951
13952 // Summary:
13953 //
13954 // Transfers multiple domain names from the current account to another account at a time.
13955 //
13956 // @param request - TransferDomainRequest
13957 //
13958 // @return TransferDomainResponse
13959 func TransferDomain(client *Client, request *TransferDomainRequest) (_result *TransferDomainResponse, _err error) {
13960 runtime := &dara.RuntimeOptions{}
13961 _result = &TransferDomainResponse{}
13962 _body, _err := TransferDomainWithOptions(client,request, runtime)
13963 if _err != nil {
13964 return _result, _err
13965 }
13966 _result = _body
13967 return _result, _err
13968 }
13969
13970 // Summary:
13971 //
13972 // Unbinds one or more domain names from a paid Alibaba Cloud DNS instance based on the instance ID.
13973 //
13974 // Description:
13975 //
13976 // A paid Alibaba Cloud DNS instance whose ID starts with dns is an instance of the new version. You can call an API operation to bind multiple domain names to the instance. If the upper limit is exceeded, an error message is returned.\\
13977 //
13978 // A paid Alibaba Cloud DNS instance whose ID does not start with dns is an instance of the old version. You can call an API operation to bind only one domain name to the instance. However, if the instance that you want to bind to the desired domain name is already bound to a domain name, you can call this operation to unbind the original domain name from the instance and then bind the desired domain name to the instance.
13979 //
13980 // @param request - UnbindInstanceDomainsRequest
13981 //
13982 // @param runtime - runtime options for this request RuntimeOptions
13983 //
13984 // @return UnbindInstanceDomainsResponse
13985 func UnbindInstanceDomainsWithOptions(client *Client, request *UnbindInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *UnbindInstanceDomainsResponse, _err error) {
13986 if dara.BoolValue(client.EnableValidate) == true {
13987 _err = request.Validate()
13988 if _err != nil {
13989 return _result, _err
13990 }
13991 }
13992 query := map[string]interface{}{}
13993 if !dara.IsNil(request.DomainNames) {
13994 query["DomainNames"] = request.DomainNames
13995 }
13996
13997 if !dara.IsNil(request.InstanceId) {
13998 query["InstanceId"] = request.InstanceId
13999 }
14000
14001 if !dara.IsNil(request.Lang) {
14002 query["Lang"] = request.Lang
14003 }
14004
14005 req := &openapiutil.OpenApiRequest{
14006 Query: openapiutil.Query(query),
14007 }
14008 params := &openapiutil.Params{
14009 Action: dara.String("UnbindInstanceDomains"),
14010 Version: dara.String("2015-01-09"),
14011 Protocol: dara.String("HTTPS"),
14012 Pathname: dara.String("/"),
14013 Method: dara.String("POST"),
14014 AuthType: dara.String("AK"),
14015 Style: dara.String("RPC"),
14016 ReqBodyType: dara.String("formData"),
14017 BodyType: dara.String("json"),
14018 }
14019 _result = &UnbindInstanceDomainsResponse{}
14020 _body, _err := client.CallApi(params, req, runtime)
14021 if _err != nil {
14022 return _result, _err
14023 }
14024 _err = dara.Convert(_body, &_result)
14025 return _result, _err
14026 }
14027
14028 // Summary:
14029 //
14030 // Unbinds one or more domain names from a paid Alibaba Cloud DNS instance based on the instance ID.
14031 //
14032 // Description:
14033 //
14034 // A paid Alibaba Cloud DNS instance whose ID starts with dns is an instance of the new version. You can call an API operation to bind multiple domain names to the instance. If the upper limit is exceeded, an error message is returned.\\
14035 //
14036 // A paid Alibaba Cloud DNS instance whose ID does not start with dns is an instance of the old version. You can call an API operation to bind only one domain name to the instance. However, if the instance that you want to bind to the desired domain name is already bound to a domain name, you can call this operation to unbind the original domain name from the instance and then bind the desired domain name to the instance.
14037 //
14038 // @param request - UnbindInstanceDomainsRequest
14039 //
14040 // @return UnbindInstanceDomainsResponse
14041 func UnbindInstanceDomains(client *Client, request *UnbindInstanceDomainsRequest) (_result *UnbindInstanceDomainsResponse, _err error) {
14042 runtime := &dara.RuntimeOptions{}
14043 _result = &UnbindInstanceDomainsResponse{}
14044 _body, _err := UnbindInstanceDomainsWithOptions(client,request, runtime)
14045 if _err != nil {
14046 return _result, _err
14047 }
14048 _result = _body
14049 return _result, _err
14050 }
14051
14052 // Summary:
14053 //
14054 // Removes tags from resources.
14055 //
14056 // @param request - UntagResourcesRequest
14057 //
14058 // @param runtime - runtime options for this request RuntimeOptions
14059 //
14060 // @return UntagResourcesResponse
14061 func UntagResourcesWithOptions(client *Client, request *UntagResourcesRequest, runtime *dara.RuntimeOptions) (_result *UntagResourcesResponse, _err error) {
14062 if dara.BoolValue(client.EnableValidate) == true {
14063 _err = request.Validate()
14064 if _err != nil {
14065 return _result, _err
14066 }
14067 }
14068 query := map[string]interface{}{}
14069 if !dara.IsNil(request.All) {
14070 query["All"] = request.All
14071 }
14072
14073 if !dara.IsNil(request.Lang) {
14074 query["Lang"] = request.Lang
14075 }
14076
14077 if !dara.IsNil(request.ResourceId) {
14078 query["ResourceId"] = request.ResourceId
14079 }
14080
14081 if !dara.IsNil(request.ResourceType) {
14082 query["ResourceType"] = request.ResourceType
14083 }
14084
14085 if !dara.IsNil(request.TagKey) {
14086 query["TagKey"] = request.TagKey
14087 }
14088
14089 req := &openapiutil.OpenApiRequest{
14090 Query: openapiutil.Query(query),
14091 }
14092 params := &openapiutil.Params{
14093 Action: dara.String("UntagResources"),
14094 Version: dara.String("2015-01-09"),
14095 Protocol: dara.String("HTTPS"),
14096 Pathname: dara.String("/"),
14097 Method: dara.String("POST"),
14098 AuthType: dara.String("AK"),
14099 Style: dara.String("RPC"),
14100 ReqBodyType: dara.String("formData"),
14101 BodyType: dara.String("json"),
14102 }
14103 _result = &UntagResourcesResponse{}
14104 _body, _err := client.CallApi(params, req, runtime)
14105 if _err != nil {
14106 return _result, _err
14107 }
14108 _err = dara.Convert(_body, &_result)
14109 return _result, _err
14110 }
14111
14112 // Summary:
14113 //
14114 // Removes tags from resources.
14115 //
14116 // @param request - UntagResourcesRequest
14117 //
14118 // @return UntagResourcesResponse
14119 func UntagResources(client *Client, request *UntagResourcesRequest) (_result *UntagResourcesResponse, _err error) {
14120 runtime := &dara.RuntimeOptions{}
14121 _result = &UntagResourcesResponse{}
14122 _body, _err := UntagResourcesWithOptions(client,request, runtime)
14123 if _err != nil {
14124 return _result, _err
14125 }
14126 _result = _body
14127 return _result, _err
14128 }
14129
14130 // Summary:
14131 //
14132 // 修改 AppKey 状态
14133 //
14134 // @param request - UpdateAppKeyStateRequest
14135 //
14136 // @param runtime - runtime options for this request RuntimeOptions
14137 //
14138 // @return UpdateAppKeyStateResponse
14139 func UpdateAppKeyStateWithOptions(client *Client, request *UpdateAppKeyStateRequest, runtime *dara.RuntimeOptions) (_result *UpdateAppKeyStateResponse, _err error) {
14140 if dara.BoolValue(client.EnableValidate) == true {
14141 _err = request.Validate()
14142 if _err != nil {
14143 return _result, _err
14144 }
14145 }
14146 query := map[string]interface{}{}
14147 if !dara.IsNil(request.AppKeyId) {
14148 query["AppKeyId"] = request.AppKeyId
14149 }
14150
14151 if !dara.IsNil(request.Lang) {
14152 query["Lang"] = request.Lang
14153 }
14154
14155 if !dara.IsNil(request.State) {
14156 query["State"] = request.State
14157 }
14158
14159 req := &openapiutil.OpenApiRequest{
14160 Query: openapiutil.Query(query),
14161 }
14162 params := &openapiutil.Params{
14163 Action: dara.String("UpdateAppKeyState"),
14164 Version: dara.String("2015-01-09"),
14165 Protocol: dara.String("HTTPS"),
14166 Pathname: dara.String("/"),
14167 Method: dara.String("POST"),
14168 AuthType: dara.String("AK"),
14169 Style: dara.String("RPC"),
14170 ReqBodyType: dara.String("formData"),
14171 BodyType: dara.String("json"),
14172 }
14173 _result = &UpdateAppKeyStateResponse{}
14174 _body, _err := client.CallApi(params, req, runtime)
14175 if _err != nil {
14176 return _result, _err
14177 }
14178 _err = dara.Convert(_body, &_result)
14179 return _result, _err
14180 }
14181
14182 // Summary:
14183 //
14184 // 修改 AppKey 状态
14185 //
14186 // @param request - UpdateAppKeyStateRequest
14187 //
14188 // @return UpdateAppKeyStateResponse
14189 func UpdateAppKeyState(client *Client, request *UpdateAppKeyStateRequest) (_result *UpdateAppKeyStateResponse, _err error) {
14190 runtime := &dara.RuntimeOptions{}
14191 _result = &UpdateAppKeyStateResponse{}
14192 _body, _err := UpdateAppKeyStateWithOptions(client,request, runtime)
14193 if _err != nil {
14194 return _result, _err
14195 }
14196 _result = _body
14197 return _result, _err
14198 }
14199
14200 // Summary:
14201 //
14202 // Modifies the condition for determining the health status of a specified address.
14203 //
14204 // @param tmpReq - UpdateCloudGtmAddressRequest
14205 //
14206 // @param runtime - runtime options for this request RuntimeOptions
14207 //
14208 // @return UpdateCloudGtmAddressResponse
14209 func UpdateCloudGtmAddressWithOptions(client *Client, tmpReq *UpdateCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressResponse, _err error) {
14210 if dara.BoolValue(client.EnableValidate) == true {
14211 _err = tmpReq.Validate()
14212 if _err != nil {
14213 return _result, _err
14214 }
14215 }
14216 request := &UpdateCloudGtmAddressShrinkRequest{}
14217 openapiutil.Convert(tmpReq, request)
14218 if !dara.IsNil(tmpReq.HealthTasks) {
14219 request.HealthTasksShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HealthTasks, dara.String("HealthTasks"), dara.String("json"))
14220 }
14221
14222 query := map[string]interface{}{}
14223 if !dara.IsNil(request.AcceptLanguage) {
14224 query["AcceptLanguage"] = request.AcceptLanguage
14225 }
14226
14227 if !dara.IsNil(request.Address) {
14228 query["Address"] = request.Address
14229 }
14230
14231 if !dara.IsNil(request.AddressId) {
14232 query["AddressId"] = request.AddressId
14233 }
14234
14235 if !dara.IsNil(request.AttributeInfo) {
14236 query["AttributeInfo"] = request.AttributeInfo
14237 }
14238
14239 if !dara.IsNil(request.ClientToken) {
14240 query["ClientToken"] = request.ClientToken
14241 }
14242
14243 if !dara.IsNil(request.HealthJudgement) {
14244 query["HealthJudgement"] = request.HealthJudgement
14245 }
14246
14247 if !dara.IsNil(request.HealthTasksShrink) {
14248 query["HealthTasks"] = request.HealthTasksShrink
14249 }
14250
14251 if !dara.IsNil(request.Name) {
14252 query["Name"] = request.Name
14253 }
14254
14255 req := &openapiutil.OpenApiRequest{
14256 Query: openapiutil.Query(query),
14257 }
14258 params := &openapiutil.Params{
14259 Action: dara.String("UpdateCloudGtmAddress"),
14260 Version: dara.String("2015-01-09"),
14261 Protocol: dara.String("HTTPS"),
14262 Pathname: dara.String("/"),
14263 Method: dara.String("POST"),
14264 AuthType: dara.String("AK"),
14265 Style: dara.String("RPC"),
14266 ReqBodyType: dara.String("formData"),
14267 BodyType: dara.String("json"),
14268 }
14269 _result = &UpdateCloudGtmAddressResponse{}
14270 _body, _err := client.CallApi(params, req, runtime)
14271 if _err != nil {
14272 return _result, _err
14273 }
14274 _err = dara.Convert(_body, &_result)
14275 return _result, _err
14276 }
14277
14278 // Summary:
14279 //
14280 // Modifies the condition for determining the health status of a specified address.
14281 //
14282 // @param request - UpdateCloudGtmAddressRequest
14283 //
14284 // @return UpdateCloudGtmAddressResponse
14285 func UpdateCloudGtmAddress(client *Client, request *UpdateCloudGtmAddressRequest) (_result *UpdateCloudGtmAddressResponse, _err error) {
14286 runtime := &dara.RuntimeOptions{}
14287 _result = &UpdateCloudGtmAddressResponse{}
14288 _body, _err := UpdateCloudGtmAddressWithOptions(client,request, runtime)
14289 if _err != nil {
14290 return _result, _err
14291 }
14292 _result = _body
14293 return _result, _err
14294 }
14295
14296 // Summary:
14297 //
14298 // Modifies the enabling status of an address.
14299 //
14300 // Description:
14301 //
14302 // If an address is **enabled* - and the health status of the address is **Normal**, the availability status of the address is **Available**.
14303 //
14304 // - If an address is **disabled* - or the health status of the address is **Abnormal**, the availability status of the address is **Unavailable**.
14305 //
14306 // @param request - UpdateCloudGtmAddressEnableStatusRequest
14307 //
14308 // @param runtime - runtime options for this request RuntimeOptions
14309 //
14310 // @return UpdateCloudGtmAddressEnableStatusResponse
14311 func UpdateCloudGtmAddressEnableStatusWithOptions(client *Client, request *UpdateCloudGtmAddressEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressEnableStatusResponse, _err error) {
14312 if dara.BoolValue(client.EnableValidate) == true {
14313 _err = request.Validate()
14314 if _err != nil {
14315 return _result, _err
14316 }
14317 }
14318 query := map[string]interface{}{}
14319 if !dara.IsNil(request.AcceptLanguage) {
14320 query["AcceptLanguage"] = request.AcceptLanguage
14321 }
14322
14323 if !dara.IsNil(request.AddressId) {
14324 query["AddressId"] = request.AddressId
14325 }
14326
14327 if !dara.IsNil(request.ClientToken) {
14328 query["ClientToken"] = request.ClientToken
14329 }
14330
14331 if !dara.IsNil(request.EnableStatus) {
14332 query["EnableStatus"] = request.EnableStatus
14333 }
14334
14335 req := &openapiutil.OpenApiRequest{
14336 Query: openapiutil.Query(query),
14337 }
14338 params := &openapiutil.Params{
14339 Action: dara.String("UpdateCloudGtmAddressEnableStatus"),
14340 Version: dara.String("2015-01-09"),
14341 Protocol: dara.String("HTTPS"),
14342 Pathname: dara.String("/"),
14343 Method: dara.String("POST"),
14344 AuthType: dara.String("AK"),
14345 Style: dara.String("RPC"),
14346 ReqBodyType: dara.String("formData"),
14347 BodyType: dara.String("json"),
14348 }
14349 _result = &UpdateCloudGtmAddressEnableStatusResponse{}
14350 _body, _err := client.CallApi(params, req, runtime)
14351 if _err != nil {
14352 return _result, _err
14353 }
14354 _err = dara.Convert(_body, &_result)
14355 return _result, _err
14356 }
14357
14358 // Summary:
14359 //
14360 // Modifies the enabling status of an address.
14361 //
14362 // Description:
14363 //
14364 // If an address is **enabled* - and the health status of the address is **Normal**, the availability status of the address is **Available**.
14365 //
14366 // - If an address is **disabled* - or the health status of the address is **Abnormal**, the availability status of the address is **Unavailable**.
14367 //
14368 // @param request - UpdateCloudGtmAddressEnableStatusRequest
14369 //
14370 // @return UpdateCloudGtmAddressEnableStatusResponse
14371 func UpdateCloudGtmAddressEnableStatus(client *Client, request *UpdateCloudGtmAddressEnableStatusRequest) (_result *UpdateCloudGtmAddressEnableStatusResponse, _err error) {
14372 runtime := &dara.RuntimeOptions{}
14373 _result = &UpdateCloudGtmAddressEnableStatusResponse{}
14374 _body, _err := UpdateCloudGtmAddressEnableStatusWithOptions(client,request, runtime)
14375 if _err != nil {
14376 return _result, _err
14377 }
14378 _result = _body
14379 return _result, _err
14380 }
14381
14382 // Summary:
14383 //
14384 // Modifies the failover mode that is used when address exceptions are identified.
14385 //
14386 // @param request - UpdateCloudGtmAddressManualAvailableStatusRequest
14387 //
14388 // @param runtime - runtime options for this request RuntimeOptions
14389 //
14390 // @return UpdateCloudGtmAddressManualAvailableStatusResponse
14391 func UpdateCloudGtmAddressManualAvailableStatusWithOptions(client *Client, request *UpdateCloudGtmAddressManualAvailableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressManualAvailableStatusResponse, _err error) {
14392 if dara.BoolValue(client.EnableValidate) == true {
14393 _err = request.Validate()
14394 if _err != nil {
14395 return _result, _err
14396 }
14397 }
14398 query := map[string]interface{}{}
14399 if !dara.IsNil(request.AcceptLanguage) {
14400 query["AcceptLanguage"] = request.AcceptLanguage
14401 }
14402
14403 if !dara.IsNil(request.AddressId) {
14404 query["AddressId"] = request.AddressId
14405 }
14406
14407 if !dara.IsNil(request.AvailableMode) {
14408 query["AvailableMode"] = request.AvailableMode
14409 }
14410
14411 if !dara.IsNil(request.ClientToken) {
14412 query["ClientToken"] = request.ClientToken
14413 }
14414
14415 if !dara.IsNil(request.ManualAvailableStatus) {
14416 query["ManualAvailableStatus"] = request.ManualAvailableStatus
14417 }
14418
14419 req := &openapiutil.OpenApiRequest{
14420 Query: openapiutil.Query(query),
14421 }
14422 params := &openapiutil.Params{
14423 Action: dara.String("UpdateCloudGtmAddressManualAvailableStatus"),
14424 Version: dara.String("2015-01-09"),
14425 Protocol: dara.String("HTTPS"),
14426 Pathname: dara.String("/"),
14427 Method: dara.String("POST"),
14428 AuthType: dara.String("AK"),
14429 Style: dara.String("RPC"),
14430 ReqBodyType: dara.String("formData"),
14431 BodyType: dara.String("json"),
14432 }
14433 _result = &UpdateCloudGtmAddressManualAvailableStatusResponse{}
14434 _body, _err := client.CallApi(params, req, runtime)
14435 if _err != nil {
14436 return _result, _err
14437 }
14438 _err = dara.Convert(_body, &_result)
14439 return _result, _err
14440 }
14441
14442 // Summary:
14443 //
14444 // Modifies the failover mode that is used when address exceptions are identified.
14445 //
14446 // @param request - UpdateCloudGtmAddressManualAvailableStatusRequest
14447 //
14448 // @return UpdateCloudGtmAddressManualAvailableStatusResponse
14449 func UpdateCloudGtmAddressManualAvailableStatus(client *Client, request *UpdateCloudGtmAddressManualAvailableStatusRequest) (_result *UpdateCloudGtmAddressManualAvailableStatusResponse, _err error) {
14450 runtime := &dara.RuntimeOptions{}
14451 _result = &UpdateCloudGtmAddressManualAvailableStatusResponse{}
14452 _body, _err := UpdateCloudGtmAddressManualAvailableStatusWithOptions(client,request, runtime)
14453 if _err != nil {
14454 return _result, _err
14455 }
14456 _result = _body
14457 return _result, _err
14458 }
14459
14460 // Summary:
14461 //
14462 // Modifies the basic configurations of an address pool.
14463 //
14464 // @param request - UpdateCloudGtmAddressPoolBasicConfigRequest
14465 //
14466 // @param runtime - runtime options for this request RuntimeOptions
14467 //
14468 // @return UpdateCloudGtmAddressPoolBasicConfigResponse
14469 func UpdateCloudGtmAddressPoolBasicConfigWithOptions(client *Client, request *UpdateCloudGtmAddressPoolBasicConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolBasicConfigResponse, _err error) {
14470 if dara.BoolValue(client.EnableValidate) == true {
14471 _err = request.Validate()
14472 if _err != nil {
14473 return _result, _err
14474 }
14475 }
14476 query := map[string]interface{}{}
14477 if !dara.IsNil(request.AcceptLanguage) {
14478 query["AcceptLanguage"] = request.AcceptLanguage
14479 }
14480
14481 if !dara.IsNil(request.AddressPoolId) {
14482 query["AddressPoolId"] = request.AddressPoolId
14483 }
14484
14485 if !dara.IsNil(request.AddressPoolName) {
14486 query["AddressPoolName"] = request.AddressPoolName
14487 }
14488
14489 if !dara.IsNil(request.ClientToken) {
14490 query["ClientToken"] = request.ClientToken
14491 }
14492
14493 if !dara.IsNil(request.HealthJudgement) {
14494 query["HealthJudgement"] = request.HealthJudgement
14495 }
14496
14497 req := &openapiutil.OpenApiRequest{
14498 Query: openapiutil.Query(query),
14499 }
14500 params := &openapiutil.Params{
14501 Action: dara.String("UpdateCloudGtmAddressPoolBasicConfig"),
14502 Version: dara.String("2015-01-09"),
14503 Protocol: dara.String("HTTPS"),
14504 Pathname: dara.String("/"),
14505 Method: dara.String("POST"),
14506 AuthType: dara.String("AK"),
14507 Style: dara.String("RPC"),
14508 ReqBodyType: dara.String("formData"),
14509 BodyType: dara.String("json"),
14510 }
14511 _result = &UpdateCloudGtmAddressPoolBasicConfigResponse{}
14512 _body, _err := client.CallApi(params, req, runtime)
14513 if _err != nil {
14514 return _result, _err
14515 }
14516 _err = dara.Convert(_body, &_result)
14517 return _result, _err
14518 }
14519
14520 // Summary:
14521 //
14522 // Modifies the basic configurations of an address pool.
14523 //
14524 // @param request - UpdateCloudGtmAddressPoolBasicConfigRequest
14525 //
14526 // @return UpdateCloudGtmAddressPoolBasicConfigResponse
14527 func UpdateCloudGtmAddressPoolBasicConfig(client *Client, request *UpdateCloudGtmAddressPoolBasicConfigRequest) (_result *UpdateCloudGtmAddressPoolBasicConfigResponse, _err error) {
14528 runtime := &dara.RuntimeOptions{}
14529 _result = &UpdateCloudGtmAddressPoolBasicConfigResponse{}
14530 _body, _err := UpdateCloudGtmAddressPoolBasicConfigWithOptions(client,request, runtime)
14531 if _err != nil {
14532 return _result, _err
14533 }
14534 _result = _body
14535 return _result, _err
14536 }
14537
14538 // Summary:
14539 //
14540 // Modifies the enabling status of an address pool.
14541 //
14542 // Description:
14543 //
14544 // If an address pool is **enabled* - and the health status of the address pool is **Normal**, the availability status of the address pool is **Available**.
14545 //
14546 // - If an address pool is **disabled* - or the health status of the address pool is **Abnormal**, the availability status of the address pool is **unavailable**.
14547 //
14548 // @param request - UpdateCloudGtmAddressPoolEnableStatusRequest
14549 //
14550 // @param runtime - runtime options for this request RuntimeOptions
14551 //
14552 // @return UpdateCloudGtmAddressPoolEnableStatusResponse
14553 func UpdateCloudGtmAddressPoolEnableStatusWithOptions(client *Client, request *UpdateCloudGtmAddressPoolEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolEnableStatusResponse, _err error) {
14554 if dara.BoolValue(client.EnableValidate) == true {
14555 _err = request.Validate()
14556 if _err != nil {
14557 return _result, _err
14558 }
14559 }
14560 query := map[string]interface{}{}
14561 if !dara.IsNil(request.AcceptLanguage) {
14562 query["AcceptLanguage"] = request.AcceptLanguage
14563 }
14564
14565 if !dara.IsNil(request.AddressPoolId) {
14566 query["AddressPoolId"] = request.AddressPoolId
14567 }
14568
14569 if !dara.IsNil(request.ClientToken) {
14570 query["ClientToken"] = request.ClientToken
14571 }
14572
14573 if !dara.IsNil(request.EnableStatus) {
14574 query["EnableStatus"] = request.EnableStatus
14575 }
14576
14577 req := &openapiutil.OpenApiRequest{
14578 Query: openapiutil.Query(query),
14579 }
14580 params := &openapiutil.Params{
14581 Action: dara.String("UpdateCloudGtmAddressPoolEnableStatus"),
14582 Version: dara.String("2015-01-09"),
14583 Protocol: dara.String("HTTPS"),
14584 Pathname: dara.String("/"),
14585 Method: dara.String("POST"),
14586 AuthType: dara.String("AK"),
14587 Style: dara.String("RPC"),
14588 ReqBodyType: dara.String("formData"),
14589 BodyType: dara.String("json"),
14590 }
14591 _result = &UpdateCloudGtmAddressPoolEnableStatusResponse{}
14592 _body, _err := client.CallApi(params, req, runtime)
14593 if _err != nil {
14594 return _result, _err
14595 }
14596 _err = dara.Convert(_body, &_result)
14597 return _result, _err
14598 }
14599
14600 // Summary:
14601 //
14602 // Modifies the enabling status of an address pool.
14603 //
14604 // Description:
14605 //
14606 // If an address pool is **enabled* - and the health status of the address pool is **Normal**, the availability status of the address pool is **Available**.
14607 //
14608 // - If an address pool is **disabled* - or the health status of the address pool is **Abnormal**, the availability status of the address pool is **unavailable**.
14609 //
14610 // @param request - UpdateCloudGtmAddressPoolEnableStatusRequest
14611 //
14612 // @return UpdateCloudGtmAddressPoolEnableStatusResponse
14613 func UpdateCloudGtmAddressPoolEnableStatus(client *Client, request *UpdateCloudGtmAddressPoolEnableStatusRequest) (_result *UpdateCloudGtmAddressPoolEnableStatusResponse, _err error) {
14614 runtime := &dara.RuntimeOptions{}
14615 _result = &UpdateCloudGtmAddressPoolEnableStatusResponse{}
14616 _body, _err := UpdateCloudGtmAddressPoolEnableStatusWithOptions(client,request, runtime)
14617 if _err != nil {
14618 return _result, _err
14619 }
14620 _result = _body
14621 return _result, _err
14622 }
14623
14624 // Summary:
14625 //
14626 // Modifies the load balancing policy of an address pool.
14627 //
14628 // @param request - UpdateCloudGtmAddressPoolLbStrategyRequest
14629 //
14630 // @param runtime - runtime options for this request RuntimeOptions
14631 //
14632 // @return UpdateCloudGtmAddressPoolLbStrategyResponse
14633 func UpdateCloudGtmAddressPoolLbStrategyWithOptions(client *Client, request *UpdateCloudGtmAddressPoolLbStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolLbStrategyResponse, _err error) {
14634 if dara.BoolValue(client.EnableValidate) == true {
14635 _err = request.Validate()
14636 if _err != nil {
14637 return _result, _err
14638 }
14639 }
14640 query := map[string]interface{}{}
14641 if !dara.IsNil(request.AcceptLanguage) {
14642 query["AcceptLanguage"] = request.AcceptLanguage
14643 }
14644
14645 if !dara.IsNil(request.AddressLbStrategy) {
14646 query["AddressLbStrategy"] = request.AddressLbStrategy
14647 }
14648
14649 if !dara.IsNil(request.AddressPoolId) {
14650 query["AddressPoolId"] = request.AddressPoolId
14651 }
14652
14653 if !dara.IsNil(request.ClientToken) {
14654 query["ClientToken"] = request.ClientToken
14655 }
14656
14657 if !dara.IsNil(request.SequenceLbStrategyMode) {
14658 query["SequenceLbStrategyMode"] = request.SequenceLbStrategyMode
14659 }
14660
14661 req := &openapiutil.OpenApiRequest{
14662 Query: openapiutil.Query(query),
14663 }
14664 params := &openapiutil.Params{
14665 Action: dara.String("UpdateCloudGtmAddressPoolLbStrategy"),
14666 Version: dara.String("2015-01-09"),
14667 Protocol: dara.String("HTTPS"),
14668 Pathname: dara.String("/"),
14669 Method: dara.String("POST"),
14670 AuthType: dara.String("AK"),
14671 Style: dara.String("RPC"),
14672 ReqBodyType: dara.String("formData"),
14673 BodyType: dara.String("json"),
14674 }
14675 _result = &UpdateCloudGtmAddressPoolLbStrategyResponse{}
14676 _body, _err := client.CallApi(params, req, runtime)
14677 if _err != nil {
14678 return _result, _err
14679 }
14680 _err = dara.Convert(_body, &_result)
14681 return _result, _err
14682 }
14683
14684 // Summary:
14685 //
14686 // Modifies the load balancing policy of an address pool.
14687 //
14688 // @param request - UpdateCloudGtmAddressPoolLbStrategyRequest
14689 //
14690 // @return UpdateCloudGtmAddressPoolLbStrategyResponse
14691 func UpdateCloudGtmAddressPoolLbStrategy(client *Client, request *UpdateCloudGtmAddressPoolLbStrategyRequest) (_result *UpdateCloudGtmAddressPoolLbStrategyResponse, _err error) {
14692 runtime := &dara.RuntimeOptions{}
14693 _result = &UpdateCloudGtmAddressPoolLbStrategyResponse{}
14694 _body, _err := UpdateCloudGtmAddressPoolLbStrategyWithOptions(client,request, runtime)
14695 if _err != nil {
14696 return _result, _err
14697 }
14698 _result = _body
14699 return _result, _err
14700 }
14701
14702 // Summary:
14703 //
14704 // Modifies the remarks of an address pool.
14705 //
14706 // @param request - UpdateCloudGtmAddressPoolRemarkRequest
14707 //
14708 // @param runtime - runtime options for this request RuntimeOptions
14709 //
14710 // @return UpdateCloudGtmAddressPoolRemarkResponse
14711 func UpdateCloudGtmAddressPoolRemarkWithOptions(client *Client, request *UpdateCloudGtmAddressPoolRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolRemarkResponse, _err error) {
14712 if dara.BoolValue(client.EnableValidate) == true {
14713 _err = request.Validate()
14714 if _err != nil {
14715 return _result, _err
14716 }
14717 }
14718 query := map[string]interface{}{}
14719 if !dara.IsNil(request.AcceptLanguage) {
14720 query["AcceptLanguage"] = request.AcceptLanguage
14721 }
14722
14723 if !dara.IsNil(request.AddressPoolId) {
14724 query["AddressPoolId"] = request.AddressPoolId
14725 }
14726
14727 if !dara.IsNil(request.ClientToken) {
14728 query["ClientToken"] = request.ClientToken
14729 }
14730
14731 if !dara.IsNil(request.Remark) {
14732 query["Remark"] = request.Remark
14733 }
14734
14735 req := &openapiutil.OpenApiRequest{
14736 Query: openapiutil.Query(query),
14737 }
14738 params := &openapiutil.Params{
14739 Action: dara.String("UpdateCloudGtmAddressPoolRemark"),
14740 Version: dara.String("2015-01-09"),
14741 Protocol: dara.String("HTTPS"),
14742 Pathname: dara.String("/"),
14743 Method: dara.String("POST"),
14744 AuthType: dara.String("AK"),
14745 Style: dara.String("RPC"),
14746 ReqBodyType: dara.String("formData"),
14747 BodyType: dara.String("json"),
14748 }
14749 _result = &UpdateCloudGtmAddressPoolRemarkResponse{}
14750 _body, _err := client.CallApi(params, req, runtime)
14751 if _err != nil {
14752 return _result, _err
14753 }
14754 _err = dara.Convert(_body, &_result)
14755 return _result, _err
14756 }
14757
14758 // Summary:
14759 //
14760 // Modifies the remarks of an address pool.
14761 //
14762 // @param request - UpdateCloudGtmAddressPoolRemarkRequest
14763 //
14764 // @return UpdateCloudGtmAddressPoolRemarkResponse
14765 func UpdateCloudGtmAddressPoolRemark(client *Client, request *UpdateCloudGtmAddressPoolRemarkRequest) (_result *UpdateCloudGtmAddressPoolRemarkResponse, _err error) {
14766 runtime := &dara.RuntimeOptions{}
14767 _result = &UpdateCloudGtmAddressPoolRemarkResponse{}
14768 _body, _err := UpdateCloudGtmAddressPoolRemarkWithOptions(client,request, runtime)
14769 if _err != nil {
14770 return _result, _err
14771 }
14772 _result = _body
14773 return _result, _err
14774 }
14775
14776 // Summary:
14777 //
14778 // Modifies the remarks of an address.
14779 //
14780 // @param request - UpdateCloudGtmAddressRemarkRequest
14781 //
14782 // @param runtime - runtime options for this request RuntimeOptions
14783 //
14784 // @return UpdateCloudGtmAddressRemarkResponse
14785 func UpdateCloudGtmAddressRemarkWithOptions(client *Client, request *UpdateCloudGtmAddressRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressRemarkResponse, _err error) {
14786 if dara.BoolValue(client.EnableValidate) == true {
14787 _err = request.Validate()
14788 if _err != nil {
14789 return _result, _err
14790 }
14791 }
14792 query := map[string]interface{}{}
14793 if !dara.IsNil(request.AcceptLanguage) {
14794 query["AcceptLanguage"] = request.AcceptLanguage
14795 }
14796
14797 if !dara.IsNil(request.AddressId) {
14798 query["AddressId"] = request.AddressId
14799 }
14800
14801 if !dara.IsNil(request.ClientToken) {
14802 query["ClientToken"] = request.ClientToken
14803 }
14804
14805 if !dara.IsNil(request.Remark) {
14806 query["Remark"] = request.Remark
14807 }
14808
14809 req := &openapiutil.OpenApiRequest{
14810 Query: openapiutil.Query(query),
14811 }
14812 params := &openapiutil.Params{
14813 Action: dara.String("UpdateCloudGtmAddressRemark"),
14814 Version: dara.String("2015-01-09"),
14815 Protocol: dara.String("HTTPS"),
14816 Pathname: dara.String("/"),
14817 Method: dara.String("POST"),
14818 AuthType: dara.String("AK"),
14819 Style: dara.String("RPC"),
14820 ReqBodyType: dara.String("formData"),
14821 BodyType: dara.String("json"),
14822 }
14823 _result = &UpdateCloudGtmAddressRemarkResponse{}
14824 _body, _err := client.CallApi(params, req, runtime)
14825 if _err != nil {
14826 return _result, _err
14827 }
14828 _err = dara.Convert(_body, &_result)
14829 return _result, _err
14830 }
14831
14832 // Summary:
14833 //
14834 // Modifies the remarks of an address.
14835 //
14836 // @param request - UpdateCloudGtmAddressRemarkRequest
14837 //
14838 // @return UpdateCloudGtmAddressRemarkResponse
14839 func UpdateCloudGtmAddressRemark(client *Client, request *UpdateCloudGtmAddressRemarkRequest) (_result *UpdateCloudGtmAddressRemarkResponse, _err error) {
14840 runtime := &dara.RuntimeOptions{}
14841 _result = &UpdateCloudGtmAddressRemarkResponse{}
14842 _body, _err := UpdateCloudGtmAddressRemarkWithOptions(client,request, runtime)
14843 if _err != nil {
14844 return _result, _err
14845 }
14846 _result = _body
14847 return _result, _err
14848 }
14849
14850 // @param tmpReq - UpdateCloudGtmGlobalAlertRequest
14851 //
14852 // @param runtime - runtime options for this request RuntimeOptions
14853 //
14854 // @return UpdateCloudGtmGlobalAlertResponse
14855 func UpdateCloudGtmGlobalAlertWithOptions(client *Client, tmpReq *UpdateCloudGtmGlobalAlertRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmGlobalAlertResponse, _err error) {
14856 if dara.BoolValue(client.EnableValidate) == true {
14857 _err = tmpReq.Validate()
14858 if _err != nil {
14859 return _result, _err
14860 }
14861 }
14862 request := &UpdateCloudGtmGlobalAlertShrinkRequest{}
14863 openapiutil.Convert(tmpReq, request)
14864 if !dara.IsNil(tmpReq.AlertConfig) {
14865 request.AlertConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertConfig, dara.String("AlertConfig"), dara.String("json"))
14866 }
14867
14868 if !dara.IsNil(tmpReq.AlertGroup) {
14869 request.AlertGroupShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertGroup, dara.String("AlertGroup"), dara.String("json"))
14870 }
14871
14872 query := map[string]interface{}{}
14873 if !dara.IsNil(request.AcceptLanguage) {
14874 query["AcceptLanguage"] = request.AcceptLanguage
14875 }
14876
14877 if !dara.IsNil(request.AlertConfigShrink) {
14878 query["AlertConfig"] = request.AlertConfigShrink
14879 }
14880
14881 if !dara.IsNil(request.AlertGroupShrink) {
14882 query["AlertGroup"] = request.AlertGroupShrink
14883 }
14884
14885 if !dara.IsNil(request.ClientToken) {
14886 query["ClientToken"] = request.ClientToken
14887 }
14888
14889 req := &openapiutil.OpenApiRequest{
14890 Query: openapiutil.Query(query),
14891 }
14892 params := &openapiutil.Params{
14893 Action: dara.String("UpdateCloudGtmGlobalAlert"),
14894 Version: dara.String("2015-01-09"),
14895 Protocol: dara.String("HTTPS"),
14896 Pathname: dara.String("/"),
14897 Method: dara.String("POST"),
14898 AuthType: dara.String("AK"),
14899 Style: dara.String("RPC"),
14900 ReqBodyType: dara.String("formData"),
14901 BodyType: dara.String("json"),
14902 }
14903 _result = &UpdateCloudGtmGlobalAlertResponse{}
14904 _body, _err := client.CallApi(params, req, runtime)
14905 if _err != nil {
14906 return _result, _err
14907 }
14908 _err = dara.Convert(_body, &_result)
14909 return _result, _err
14910 }
14911
14912 // @param request - UpdateCloudGtmGlobalAlertRequest
14913 //
14914 // @return UpdateCloudGtmGlobalAlertResponse
14915 func UpdateCloudGtmGlobalAlert(client *Client, request *UpdateCloudGtmGlobalAlertRequest) (_result *UpdateCloudGtmGlobalAlertResponse, _err error) {
14916 runtime := &dara.RuntimeOptions{}
14917 _result = &UpdateCloudGtmGlobalAlertResponse{}
14918 _body, _err := UpdateCloudGtmGlobalAlertWithOptions(client,request, runtime)
14919 if _err != nil {
14920 return _result, _err
14921 }
14922 _result = _body
14923 return _result, _err
14924 }
14925
14926 // @param tmpReq - UpdateCloudGtmInstanceConfigAlertRequest
14927 //
14928 // @param runtime - runtime options for this request RuntimeOptions
14929 //
14930 // @return UpdateCloudGtmInstanceConfigAlertResponse
14931 func UpdateCloudGtmInstanceConfigAlertWithOptions(client *Client, tmpReq *UpdateCloudGtmInstanceConfigAlertRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigAlertResponse, _err error) {
14932 if dara.BoolValue(client.EnableValidate) == true {
14933 _err = tmpReq.Validate()
14934 if _err != nil {
14935 return _result, _err
14936 }
14937 }
14938 request := &UpdateCloudGtmInstanceConfigAlertShrinkRequest{}
14939 openapiutil.Convert(tmpReq, request)
14940 if !dara.IsNil(tmpReq.AlertConfig) {
14941 request.AlertConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertConfig, dara.String("AlertConfig"), dara.String("json"))
14942 }
14943
14944 if !dara.IsNil(tmpReq.AlertGroup) {
14945 request.AlertGroupShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertGroup, dara.String("AlertGroup"), dara.String("json"))
14946 }
14947
14948 query := map[string]interface{}{}
14949 if !dara.IsNil(request.AcceptLanguage) {
14950 query["AcceptLanguage"] = request.AcceptLanguage
14951 }
14952
14953 if !dara.IsNil(request.AlertConfigShrink) {
14954 query["AlertConfig"] = request.AlertConfigShrink
14955 }
14956
14957 if !dara.IsNil(request.AlertGroupShrink) {
14958 query["AlertGroup"] = request.AlertGroupShrink
14959 }
14960
14961 if !dara.IsNil(request.AlertMode) {
14962 query["AlertMode"] = request.AlertMode
14963 }
14964
14965 if !dara.IsNil(request.ClientToken) {
14966 query["ClientToken"] = request.ClientToken
14967 }
14968
14969 if !dara.IsNil(request.ConfigId) {
14970 query["ConfigId"] = request.ConfigId
14971 }
14972
14973 if !dara.IsNil(request.InstanceId) {
14974 query["InstanceId"] = request.InstanceId
14975 }
14976
14977 req := &openapiutil.OpenApiRequest{
14978 Query: openapiutil.Query(query),
14979 }
14980 params := &openapiutil.Params{
14981 Action: dara.String("UpdateCloudGtmInstanceConfigAlert"),
14982 Version: dara.String("2015-01-09"),
14983 Protocol: dara.String("HTTPS"),
14984 Pathname: dara.String("/"),
14985 Method: dara.String("POST"),
14986 AuthType: dara.String("AK"),
14987 Style: dara.String("RPC"),
14988 ReqBodyType: dara.String("formData"),
14989 BodyType: dara.String("json"),
14990 }
14991 _result = &UpdateCloudGtmInstanceConfigAlertResponse{}
14992 _body, _err := client.CallApi(params, req, runtime)
14993 if _err != nil {
14994 return _result, _err
14995 }
14996 _err = dara.Convert(_body, &_result)
14997 return _result, _err
14998 }
14999
15000 // @param request - UpdateCloudGtmInstanceConfigAlertRequest
15001 //
15002 // @return UpdateCloudGtmInstanceConfigAlertResponse
15003 func UpdateCloudGtmInstanceConfigAlert(client *Client, request *UpdateCloudGtmInstanceConfigAlertRequest) (_result *UpdateCloudGtmInstanceConfigAlertResponse, _err error) {
15004 runtime := &dara.RuntimeOptions{}
15005 _result = &UpdateCloudGtmInstanceConfigAlertResponse{}
15006 _body, _err := UpdateCloudGtmInstanceConfigAlertWithOptions(client,request, runtime)
15007 if _err != nil {
15008 return _result, _err
15009 }
15010 _result = _body
15011 return _result, _err
15012 }
15013
15014 // Summary:
15015 //
15016 // Updates the global time-to-live (TTL) configuration of a GTM 3.0 instance.
15017 //
15018 // @param request - UpdateCloudGtmInstanceConfigBasicRequest
15019 //
15020 // @param runtime - runtime options for this request RuntimeOptions
15021 //
15022 // @return UpdateCloudGtmInstanceConfigBasicResponse
15023 func UpdateCloudGtmInstanceConfigBasicWithOptions(client *Client, request *UpdateCloudGtmInstanceConfigBasicRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigBasicResponse, _err error) {
15024 if dara.BoolValue(client.EnableValidate) == true {
15025 _err = request.Validate()
15026 if _err != nil {
15027 return _result, _err
15028 }
15029 }
15030 query := map[string]interface{}{}
15031 if !dara.IsNil(request.AcceptLanguage) {
15032 query["AcceptLanguage"] = request.AcceptLanguage
15033 }
15034
15035 if !dara.IsNil(request.ClientToken) {
15036 query["ClientToken"] = request.ClientToken
15037 }
15038
15039 if !dara.IsNil(request.ConfigId) {
15040 query["ConfigId"] = request.ConfigId
15041 }
15042
15043 if !dara.IsNil(request.InstanceId) {
15044 query["InstanceId"] = request.InstanceId
15045 }
15046
15047 if !dara.IsNil(request.ScheduleHostname) {
15048 query["ScheduleHostname"] = request.ScheduleHostname
15049 }
15050
15051 if !dara.IsNil(request.ScheduleZoneName) {
15052 query["ScheduleZoneName"] = request.ScheduleZoneName
15053 }
15054
15055 if !dara.IsNil(request.Ttl) {
15056 query["Ttl"] = request.Ttl
15057 }
15058
15059 req := &openapiutil.OpenApiRequest{
15060 Query: openapiutil.Query(query),
15061 }
15062 params := &openapiutil.Params{
15063 Action: dara.String("UpdateCloudGtmInstanceConfigBasic"),
15064 Version: dara.String("2015-01-09"),
15065 Protocol: dara.String("HTTPS"),
15066 Pathname: dara.String("/"),
15067 Method: dara.String("POST"),
15068 AuthType: dara.String("AK"),
15069 Style: dara.String("RPC"),
15070 ReqBodyType: dara.String("formData"),
15071 BodyType: dara.String("json"),
15072 }
15073 _result = &UpdateCloudGtmInstanceConfigBasicResponse{}
15074 _body, _err := client.CallApi(params, req, runtime)
15075 if _err != nil {
15076 return _result, _err
15077 }
15078 _err = dara.Convert(_body, &_result)
15079 return _result, _err
15080 }
15081
15082 // Summary:
15083 //
15084 // Updates the global time-to-live (TTL) configuration of a GTM 3.0 instance.
15085 //
15086 // @param request - UpdateCloudGtmInstanceConfigBasicRequest
15087 //
15088 // @return UpdateCloudGtmInstanceConfigBasicResponse
15089 func UpdateCloudGtmInstanceConfigBasic(client *Client, request *UpdateCloudGtmInstanceConfigBasicRequest) (_result *UpdateCloudGtmInstanceConfigBasicResponse, _err error) {
15090 runtime := &dara.RuntimeOptions{}
15091 _result = &UpdateCloudGtmInstanceConfigBasicResponse{}
15092 _body, _err := UpdateCloudGtmInstanceConfigBasicWithOptions(client,request, runtime)
15093 if _err != nil {
15094 return _result, _err
15095 }
15096 _result = _body
15097 return _result, _err
15098 }
15099
15100 // Summary:
15101 //
15102 // Modifies the enabling status of an access domain name.
15103 //
15104 // Description:
15105 //
15106 // If an access domain name is **enabled* - and the health state is **normal**, the access domain name is deemed **available**.
15107 //
15108 // - If an access domain name is **disabled* - or the health state is **abnormal**, the access domain name is deemed **unavailable**.
15109 //
15110 // @param request - UpdateCloudGtmInstanceConfigEnableStatusRequest
15111 //
15112 // @param runtime - runtime options for this request RuntimeOptions
15113 //
15114 // @return UpdateCloudGtmInstanceConfigEnableStatusResponse
15115 func UpdateCloudGtmInstanceConfigEnableStatusWithOptions(client *Client, request *UpdateCloudGtmInstanceConfigEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigEnableStatusResponse, _err error) {
15116 if dara.BoolValue(client.EnableValidate) == true {
15117 _err = request.Validate()
15118 if _err != nil {
15119 return _result, _err
15120 }
15121 }
15122 query := map[string]interface{}{}
15123 if !dara.IsNil(request.AcceptLanguage) {
15124 query["AcceptLanguage"] = request.AcceptLanguage
15125 }
15126
15127 if !dara.IsNil(request.ClientToken) {
15128 query["ClientToken"] = request.ClientToken
15129 }
15130
15131 if !dara.IsNil(request.ConfigId) {
15132 query["ConfigId"] = request.ConfigId
15133 }
15134
15135 if !dara.IsNil(request.EnableStatus) {
15136 query["EnableStatus"] = request.EnableStatus
15137 }
15138
15139 if !dara.IsNil(request.InstanceId) {
15140 query["InstanceId"] = request.InstanceId
15141 }
15142
15143 req := &openapiutil.OpenApiRequest{
15144 Query: openapiutil.Query(query),
15145 }
15146 params := &openapiutil.Params{
15147 Action: dara.String("UpdateCloudGtmInstanceConfigEnableStatus"),
15148 Version: dara.String("2015-01-09"),
15149 Protocol: dara.String("HTTPS"),
15150 Pathname: dara.String("/"),
15151 Method: dara.String("POST"),
15152 AuthType: dara.String("AK"),
15153 Style: dara.String("RPC"),
15154 ReqBodyType: dara.String("formData"),
15155 BodyType: dara.String("json"),
15156 }
15157 _result = &UpdateCloudGtmInstanceConfigEnableStatusResponse{}
15158 _body, _err := client.CallApi(params, req, runtime)
15159 if _err != nil {
15160 return _result, _err
15161 }
15162 _err = dara.Convert(_body, &_result)
15163 return _result, _err
15164 }
15165
15166 // Summary:
15167 //
15168 // Modifies the enabling status of an access domain name.
15169 //
15170 // Description:
15171 //
15172 // If an access domain name is **enabled* - and the health state is **normal**, the access domain name is deemed **available**.
15173 //
15174 // - If an access domain name is **disabled* - or the health state is **abnormal**, the access domain name is deemed **unavailable**.
15175 //
15176 // @param request - UpdateCloudGtmInstanceConfigEnableStatusRequest
15177 //
15178 // @return UpdateCloudGtmInstanceConfigEnableStatusResponse
15179 func UpdateCloudGtmInstanceConfigEnableStatus(client *Client, request *UpdateCloudGtmInstanceConfigEnableStatusRequest) (_result *UpdateCloudGtmInstanceConfigEnableStatusResponse, _err error) {
15180 runtime := &dara.RuntimeOptions{}
15181 _result = &UpdateCloudGtmInstanceConfigEnableStatusResponse{}
15182 _body, _err := UpdateCloudGtmInstanceConfigEnableStatusWithOptions(client,request, runtime)
15183 if _err != nil {
15184 return _result, _err
15185 }
15186 _result = _body
15187 return _result, _err
15188 }
15189
15190 // Summary:
15191 //
15192 // Modifies the load balancing policy of a Global Traffic Manager (GTM) 3.0 instance.
15193 //
15194 // @param request - UpdateCloudGtmInstanceConfigLbStrategyRequest
15195 //
15196 // @param runtime - runtime options for this request RuntimeOptions
15197 //
15198 // @return UpdateCloudGtmInstanceConfigLbStrategyResponse
15199 func UpdateCloudGtmInstanceConfigLbStrategyWithOptions(client *Client, request *UpdateCloudGtmInstanceConfigLbStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigLbStrategyResponse, _err error) {
15200 if dara.BoolValue(client.EnableValidate) == true {
15201 _err = request.Validate()
15202 if _err != nil {
15203 return _result, _err
15204 }
15205 }
15206 query := map[string]interface{}{}
15207 if !dara.IsNil(request.AcceptLanguage) {
15208 query["AcceptLanguage"] = request.AcceptLanguage
15209 }
15210
15211 if !dara.IsNil(request.AddressPoolLbStrategy) {
15212 query["AddressPoolLbStrategy"] = request.AddressPoolLbStrategy
15213 }
15214
15215 if !dara.IsNil(request.ClientToken) {
15216 query["ClientToken"] = request.ClientToken
15217 }
15218
15219 if !dara.IsNil(request.ConfigId) {
15220 query["ConfigId"] = request.ConfigId
15221 }
15222
15223 if !dara.IsNil(request.InstanceId) {
15224 query["InstanceId"] = request.InstanceId
15225 }
15226
15227 if !dara.IsNil(request.SequenceLbStrategyMode) {
15228 query["SequenceLbStrategyMode"] = request.SequenceLbStrategyMode
15229 }
15230
15231 req := &openapiutil.OpenApiRequest{
15232 Query: openapiutil.Query(query),
15233 }
15234 params := &openapiutil.Params{
15235 Action: dara.String("UpdateCloudGtmInstanceConfigLbStrategy"),
15236 Version: dara.String("2015-01-09"),
15237 Protocol: dara.String("HTTPS"),
15238 Pathname: dara.String("/"),
15239 Method: dara.String("POST"),
15240 AuthType: dara.String("AK"),
15241 Style: dara.String("RPC"),
15242 ReqBodyType: dara.String("formData"),
15243 BodyType: dara.String("json"),
15244 }
15245 _result = &UpdateCloudGtmInstanceConfigLbStrategyResponse{}
15246 _body, _err := client.CallApi(params, req, runtime)
15247 if _err != nil {
15248 return _result, _err
15249 }
15250 _err = dara.Convert(_body, &_result)
15251 return _result, _err
15252 }
15253
15254 // Summary:
15255 //
15256 // Modifies the load balancing policy of a Global Traffic Manager (GTM) 3.0 instance.
15257 //
15258 // @param request - UpdateCloudGtmInstanceConfigLbStrategyRequest
15259 //
15260 // @return UpdateCloudGtmInstanceConfigLbStrategyResponse
15261 func UpdateCloudGtmInstanceConfigLbStrategy(client *Client, request *UpdateCloudGtmInstanceConfigLbStrategyRequest) (_result *UpdateCloudGtmInstanceConfigLbStrategyResponse, _err error) {
15262 runtime := &dara.RuntimeOptions{}
15263 _result = &UpdateCloudGtmInstanceConfigLbStrategyResponse{}
15264 _body, _err := UpdateCloudGtmInstanceConfigLbStrategyWithOptions(client,request, runtime)
15265 if _err != nil {
15266 return _result, _err
15267 }
15268 _result = _body
15269 return _result, _err
15270 }
15271
15272 // Summary:
15273 //
15274 // Modifies the description of a Global Traffic Manager (GTM) 3.0 instance.
15275 //
15276 // @param request - UpdateCloudGtmInstanceConfigRemarkRequest
15277 //
15278 // @param runtime - runtime options for this request RuntimeOptions
15279 //
15280 // @return UpdateCloudGtmInstanceConfigRemarkResponse
15281 func UpdateCloudGtmInstanceConfigRemarkWithOptions(client *Client, request *UpdateCloudGtmInstanceConfigRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigRemarkResponse, _err error) {
15282 if dara.BoolValue(client.EnableValidate) == true {
15283 _err = request.Validate()
15284 if _err != nil {
15285 return _result, _err
15286 }
15287 }
15288 query := map[string]interface{}{}
15289 if !dara.IsNil(request.AcceptLanguage) {
15290 query["AcceptLanguage"] = request.AcceptLanguage
15291 }
15292
15293 if !dara.IsNil(request.ClientToken) {
15294 query["ClientToken"] = request.ClientToken
15295 }
15296
15297 if !dara.IsNil(request.ConfigId) {
15298 query["ConfigId"] = request.ConfigId
15299 }
15300
15301 if !dara.IsNil(request.InstanceId) {
15302 query["InstanceId"] = request.InstanceId
15303 }
15304
15305 if !dara.IsNil(request.Remark) {
15306 query["Remark"] = request.Remark
15307 }
15308
15309 req := &openapiutil.OpenApiRequest{
15310 Query: openapiutil.Query(query),
15311 }
15312 params := &openapiutil.Params{
15313 Action: dara.String("UpdateCloudGtmInstanceConfigRemark"),
15314 Version: dara.String("2015-01-09"),
15315 Protocol: dara.String("HTTPS"),
15316 Pathname: dara.String("/"),
15317 Method: dara.String("POST"),
15318 AuthType: dara.String("AK"),
15319 Style: dara.String("RPC"),
15320 ReqBodyType: dara.String("formData"),
15321 BodyType: dara.String("json"),
15322 }
15323 _result = &UpdateCloudGtmInstanceConfigRemarkResponse{}
15324 _body, _err := client.CallApi(params, req, runtime)
15325 if _err != nil {
15326 return _result, _err
15327 }
15328 _err = dara.Convert(_body, &_result)
15329 return _result, _err
15330 }
15331
15332 // Summary:
15333 //
15334 // Modifies the description of a Global Traffic Manager (GTM) 3.0 instance.
15335 //
15336 // @param request - UpdateCloudGtmInstanceConfigRemarkRequest
15337 //
15338 // @return UpdateCloudGtmInstanceConfigRemarkResponse
15339 func UpdateCloudGtmInstanceConfigRemark(client *Client, request *UpdateCloudGtmInstanceConfigRemarkRequest) (_result *UpdateCloudGtmInstanceConfigRemarkResponse, _err error) {
15340 runtime := &dara.RuntimeOptions{}
15341 _result = &UpdateCloudGtmInstanceConfigRemarkResponse{}
15342 _body, _err := UpdateCloudGtmInstanceConfigRemarkWithOptions(client,request, runtime)
15343 if _err != nil {
15344 return _result, _err
15345 }
15346 _result = _body
15347 return _result, _err
15348 }
15349
15350 // @param request - UpdateCloudGtmInstanceNameRequest
15351 //
15352 // @param runtime - runtime options for this request RuntimeOptions
15353 //
15354 // @return UpdateCloudGtmInstanceNameResponse
15355 func UpdateCloudGtmInstanceNameWithOptions(client *Client, request *UpdateCloudGtmInstanceNameRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceNameResponse, _err error) {
15356 if dara.BoolValue(client.EnableValidate) == true {
15357 _err = request.Validate()
15358 if _err != nil {
15359 return _result, _err
15360 }
15361 }
15362 query := map[string]interface{}{}
15363 if !dara.IsNil(request.AcceptLanguage) {
15364 query["AcceptLanguage"] = request.AcceptLanguage
15365 }
15366
15367 if !dara.IsNil(request.ClientToken) {
15368 query["ClientToken"] = request.ClientToken
15369 }
15370
15371 if !dara.IsNil(request.InstanceId) {
15372 query["InstanceId"] = request.InstanceId
15373 }
15374
15375 if !dara.IsNil(request.InstanceName) {
15376 query["InstanceName"] = request.InstanceName
15377 }
15378
15379 req := &openapiutil.OpenApiRequest{
15380 Query: openapiutil.Query(query),
15381 }
15382 params := &openapiutil.Params{
15383 Action: dara.String("UpdateCloudGtmInstanceName"),
15384 Version: dara.String("2015-01-09"),
15385 Protocol: dara.String("HTTPS"),
15386 Pathname: dara.String("/"),
15387 Method: dara.String("POST"),
15388 AuthType: dara.String("AK"),
15389 Style: dara.String("RPC"),
15390 ReqBodyType: dara.String("formData"),
15391 BodyType: dara.String("json"),
15392 }
15393 _result = &UpdateCloudGtmInstanceNameResponse{}
15394 _body, _err := client.CallApi(params, req, runtime)
15395 if _err != nil {
15396 return _result, _err
15397 }
15398 _err = dara.Convert(_body, &_result)
15399 return _result, _err
15400 }
15401
15402 // @param request - UpdateCloudGtmInstanceNameRequest
15403 //
15404 // @return UpdateCloudGtmInstanceNameResponse
15405 func UpdateCloudGtmInstanceName(client *Client, request *UpdateCloudGtmInstanceNameRequest) (_result *UpdateCloudGtmInstanceNameResponse, _err error) {
15406 runtime := &dara.RuntimeOptions{}
15407 _result = &UpdateCloudGtmInstanceNameResponse{}
15408 _body, _err := UpdateCloudGtmInstanceNameWithOptions(client,request, runtime)
15409 if _err != nil {
15410 return _result, _err
15411 }
15412 _result = _body
15413 return _result, _err
15414 }
15415
15416 // Summary:
15417 //
15418 // Modifies the information about a health check template.
15419 //
15420 // @param tmpReq - UpdateCloudGtmMonitorTemplateRequest
15421 //
15422 // @param runtime - runtime options for this request RuntimeOptions
15423 //
15424 // @return UpdateCloudGtmMonitorTemplateResponse
15425 func UpdateCloudGtmMonitorTemplateWithOptions(client *Client, tmpReq *UpdateCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmMonitorTemplateResponse, _err error) {
15426 if dara.BoolValue(client.EnableValidate) == true {
15427 _err = tmpReq.Validate()
15428 if _err != nil {
15429 return _result, _err
15430 }
15431 }
15432 request := &UpdateCloudGtmMonitorTemplateShrinkRequest{}
15433 openapiutil.Convert(tmpReq, request)
15434 if !dara.IsNil(tmpReq.IspCityNodes) {
15435 request.IspCityNodesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.IspCityNodes, dara.String("IspCityNodes"), dara.String("json"))
15436 }
15437
15438 query := map[string]interface{}{}
15439 if !dara.IsNil(request.AcceptLanguage) {
15440 query["AcceptLanguage"] = request.AcceptLanguage
15441 }
15442
15443 if !dara.IsNil(request.ClientToken) {
15444 query["ClientToken"] = request.ClientToken
15445 }
15446
15447 if !dara.IsNil(request.EvaluationCount) {
15448 query["EvaluationCount"] = request.EvaluationCount
15449 }
15450
15451 if !dara.IsNil(request.ExtendInfo) {
15452 query["ExtendInfo"] = request.ExtendInfo
15453 }
15454
15455 if !dara.IsNil(request.FailureRate) {
15456 query["FailureRate"] = request.FailureRate
15457 }
15458
15459 if !dara.IsNil(request.Interval) {
15460 query["Interval"] = request.Interval
15461 }
15462
15463 if !dara.IsNil(request.IspCityNodesShrink) {
15464 query["IspCityNodes"] = request.IspCityNodesShrink
15465 }
15466
15467 if !dara.IsNil(request.Name) {
15468 query["Name"] = request.Name
15469 }
15470
15471 if !dara.IsNil(request.TemplateId) {
15472 query["TemplateId"] = request.TemplateId
15473 }
15474
15475 if !dara.IsNil(request.Timeout) {
15476 query["Timeout"] = request.Timeout
15477 }
15478
15479 req := &openapiutil.OpenApiRequest{
15480 Query: openapiutil.Query(query),
15481 }
15482 params := &openapiutil.Params{
15483 Action: dara.String("UpdateCloudGtmMonitorTemplate"),
15484 Version: dara.String("2015-01-09"),
15485 Protocol: dara.String("HTTPS"),
15486 Pathname: dara.String("/"),
15487 Method: dara.String("POST"),
15488 AuthType: dara.String("AK"),
15489 Style: dara.String("RPC"),
15490 ReqBodyType: dara.String("formData"),
15491 BodyType: dara.String("json"),
15492 }
15493 _result = &UpdateCloudGtmMonitorTemplateResponse{}
15494 _body, _err := client.CallApi(params, req, runtime)
15495 if _err != nil {
15496 return _result, _err
15497 }
15498 _err = dara.Convert(_body, &_result)
15499 return _result, _err
15500 }
15501
15502 // Summary:
15503 //
15504 // Modifies the information about a health check template.
15505 //
15506 // @param request - UpdateCloudGtmMonitorTemplateRequest
15507 //
15508 // @return UpdateCloudGtmMonitorTemplateResponse
15509 func UpdateCloudGtmMonitorTemplate(client *Client, request *UpdateCloudGtmMonitorTemplateRequest) (_result *UpdateCloudGtmMonitorTemplateResponse, _err error) {
15510 runtime := &dara.RuntimeOptions{}
15511 _result = &UpdateCloudGtmMonitorTemplateResponse{}
15512 _body, _err := UpdateCloudGtmMonitorTemplateWithOptions(client,request, runtime)
15513 if _err != nil {
15514 return _result, _err
15515 }
15516 _result = _body
15517 return _result, _err
15518 }
15519
15520 // @param request - UpdateCloudGtmMonitorTemplateRemarkRequest
15521 //
15522 // @param runtime - runtime options for this request RuntimeOptions
15523 //
15524 // @return UpdateCloudGtmMonitorTemplateRemarkResponse
15525 func UpdateCloudGtmMonitorTemplateRemarkWithOptions(client *Client, request *UpdateCloudGtmMonitorTemplateRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmMonitorTemplateRemarkResponse, _err error) {
15526 if dara.BoolValue(client.EnableValidate) == true {
15527 _err = request.Validate()
15528 if _err != nil {
15529 return _result, _err
15530 }
15531 }
15532 query := map[string]interface{}{}
15533 if !dara.IsNil(request.AcceptLanguage) {
15534 query["AcceptLanguage"] = request.AcceptLanguage
15535 }
15536
15537 if !dara.IsNil(request.ClientToken) {
15538 query["ClientToken"] = request.ClientToken
15539 }
15540
15541 if !dara.IsNil(request.Remark) {
15542 query["Remark"] = request.Remark
15543 }
15544
15545 if !dara.IsNil(request.TemplateId) {
15546 query["TemplateId"] = request.TemplateId
15547 }
15548
15549 req := &openapiutil.OpenApiRequest{
15550 Query: openapiutil.Query(query),
15551 }
15552 params := &openapiutil.Params{
15553 Action: dara.String("UpdateCloudGtmMonitorTemplateRemark"),
15554 Version: dara.String("2015-01-09"),
15555 Protocol: dara.String("HTTPS"),
15556 Pathname: dara.String("/"),
15557 Method: dara.String("POST"),
15558 AuthType: dara.String("AK"),
15559 Style: dara.String("RPC"),
15560 ReqBodyType: dara.String("formData"),
15561 BodyType: dara.String("json"),
15562 }
15563 _result = &UpdateCloudGtmMonitorTemplateRemarkResponse{}
15564 _body, _err := client.CallApi(params, req, runtime)
15565 if _err != nil {
15566 return _result, _err
15567 }
15568 _err = dara.Convert(_body, &_result)
15569 return _result, _err
15570 }
15571
15572 // @param request - UpdateCloudGtmMonitorTemplateRemarkRequest
15573 //
15574 // @return UpdateCloudGtmMonitorTemplateRemarkResponse
15575 func UpdateCloudGtmMonitorTemplateRemark(client *Client, request *UpdateCloudGtmMonitorTemplateRemarkRequest) (_result *UpdateCloudGtmMonitorTemplateRemarkResponse, _err error) {
15576 runtime := &dara.RuntimeOptions{}
15577 _result = &UpdateCloudGtmMonitorTemplateRemarkResponse{}
15578 _body, _err := UpdateCloudGtmMonitorTemplateRemarkWithOptions(client,request, runtime)
15579 if _err != nil {
15580 return _result, _err
15581 }
15582 _result = _body
15583 return _result, _err
15584 }
15585
15586 // Summary:
15587 //
15588 // Modifies a custom line with its unique ID.
15589 //
15590 // Description:
15591 //
15592 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
15593 //
15594 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
15595 //
15596 // @param request - UpdateCustomLineRequest
15597 //
15598 // @param runtime - runtime options for this request RuntimeOptions
15599 //
15600 // @return UpdateCustomLineResponse
15601 func UpdateCustomLineWithOptions(client *Client, request *UpdateCustomLineRequest, runtime *dara.RuntimeOptions) (_result *UpdateCustomLineResponse, _err error) {
15602 if dara.BoolValue(client.EnableValidate) == true {
15603 _err = request.Validate()
15604 if _err != nil {
15605 return _result, _err
15606 }
15607 }
15608 query := map[string]interface{}{}
15609 if !dara.IsNil(request.IpSegment) {
15610 query["IpSegment"] = request.IpSegment
15611 }
15612
15613 if !dara.IsNil(request.Lang) {
15614 query["Lang"] = request.Lang
15615 }
15616
15617 if !dara.IsNil(request.LineId) {
15618 query["LineId"] = request.LineId
15619 }
15620
15621 if !dara.IsNil(request.LineName) {
15622 query["LineName"] = request.LineName
15623 }
15624
15625 req := &openapiutil.OpenApiRequest{
15626 Query: openapiutil.Query(query),
15627 }
15628 params := &openapiutil.Params{
15629 Action: dara.String("UpdateCustomLine"),
15630 Version: dara.String("2015-01-09"),
15631 Protocol: dara.String("HTTPS"),
15632 Pathname: dara.String("/"),
15633 Method: dara.String("POST"),
15634 AuthType: dara.String("AK"),
15635 Style: dara.String("RPC"),
15636 ReqBodyType: dara.String("formData"),
15637 BodyType: dara.String("json"),
15638 }
15639 _result = &UpdateCustomLineResponse{}
15640 _body, _err := client.CallApi(params, req, runtime)
15641 if _err != nil {
15642 return _result, _err
15643 }
15644 _err = dara.Convert(_body, &_result)
15645 return _result, _err
15646 }
15647
15648 // Summary:
15649 //
15650 // Modifies a custom line with its unique ID.
15651 //
15652 // Description:
15653 //
15654 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
15655 //
15656 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
15657 //
15658 // @param request - UpdateCustomLineRequest
15659 //
15660 // @return UpdateCustomLineResponse
15661 func UpdateCustomLine(client *Client, request *UpdateCustomLineRequest) (_result *UpdateCustomLineResponse, _err error) {
15662 runtime := &dara.RuntimeOptions{}
15663 _result = &UpdateCustomLineResponse{}
15664 _body, _err := UpdateCustomLineWithOptions(client,request, runtime)
15665 if _err != nil {
15666 return _result, _err
15667 }
15668 _result = _body
15669 return _result, _err
15670 }
15671
15672 // Summary:
15673 //
15674 // Modifies the weight of a Domain Name System (DNS) record based on the specified parameters.
15675 //
15676 // @param request - UpdateDNSSLBWeightRequest
15677 //
15678 // @param runtime - runtime options for this request RuntimeOptions
15679 //
15680 // @return UpdateDNSSLBWeightResponse
15681 func UpdateDNSSLBWeightWithOptions(client *Client, request *UpdateDNSSLBWeightRequest, runtime *dara.RuntimeOptions) (_result *UpdateDNSSLBWeightResponse, _err error) {
15682 if dara.BoolValue(client.EnableValidate) == true {
15683 _err = request.Validate()
15684 if _err != nil {
15685 return _result, _err
15686 }
15687 }
15688 query := map[string]interface{}{}
15689 if !dara.IsNil(request.Lang) {
15690 query["Lang"] = request.Lang
15691 }
15692
15693 if !dara.IsNil(request.RecordId) {
15694 query["RecordId"] = request.RecordId
15695 }
15696
15697 if !dara.IsNil(request.UserClientIp) {
15698 query["UserClientIp"] = request.UserClientIp
15699 }
15700
15701 if !dara.IsNil(request.Weight) {
15702 query["Weight"] = request.Weight
15703 }
15704
15705 req := &openapiutil.OpenApiRequest{
15706 Query: openapiutil.Query(query),
15707 }
15708 params := &openapiutil.Params{
15709 Action: dara.String("UpdateDNSSLBWeight"),
15710 Version: dara.String("2015-01-09"),
15711 Protocol: dara.String("HTTPS"),
15712 Pathname: dara.String("/"),
15713 Method: dara.String("POST"),
15714 AuthType: dara.String("AK"),
15715 Style: dara.String("RPC"),
15716 ReqBodyType: dara.String("formData"),
15717 BodyType: dara.String("json"),
15718 }
15719 _result = &UpdateDNSSLBWeightResponse{}
15720 _body, _err := client.CallApi(params, req, runtime)
15721 if _err != nil {
15722 return _result, _err
15723 }
15724 _err = dara.Convert(_body, &_result)
15725 return _result, _err
15726 }
15727
15728 // Summary:
15729 //
15730 // Modifies the weight of a Domain Name System (DNS) record based on the specified parameters.
15731 //
15732 // @param request - UpdateDNSSLBWeightRequest
15733 //
15734 // @return UpdateDNSSLBWeightResponse
15735 func UpdateDNSSLBWeight(client *Client, request *UpdateDNSSLBWeightRequest) (_result *UpdateDNSSLBWeightResponse, _err error) {
15736 runtime := &dara.RuntimeOptions{}
15737 _result = &UpdateDNSSLBWeightResponse{}
15738 _body, _err := UpdateDNSSLBWeightWithOptions(client,request, runtime)
15739 if _err != nil {
15740 return _result, _err
15741 }
15742 _result = _body
15743 return _result, _err
15744 }
15745
15746 // Summary:
15747 //
15748 // Updates the cache-accelerated domain name based on the specified parameters.
15749 //
15750 // @param request - UpdateDnsCacheDomainRequest
15751 //
15752 // @param runtime - runtime options for this request RuntimeOptions
15753 //
15754 // @return UpdateDnsCacheDomainResponse
15755 func UpdateDnsCacheDomainWithOptions(client *Client, request *UpdateDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsCacheDomainResponse, _err error) {
15756 if dara.BoolValue(client.EnableValidate) == true {
15757 _err = request.Validate()
15758 if _err != nil {
15759 return _result, _err
15760 }
15761 }
15762 query := map[string]interface{}{}
15763 if !dara.IsNil(request.CacheTtlMax) {
15764 query["CacheTtlMax"] = request.CacheTtlMax
15765 }
15766
15767 if !dara.IsNil(request.CacheTtlMin) {
15768 query["CacheTtlMin"] = request.CacheTtlMin
15769 }
15770
15771 if !dara.IsNil(request.DomainName) {
15772 query["DomainName"] = request.DomainName
15773 }
15774
15775 if !dara.IsNil(request.InstanceId) {
15776 query["InstanceId"] = request.InstanceId
15777 }
15778
15779 if !dara.IsNil(request.Lang) {
15780 query["Lang"] = request.Lang
15781 }
15782
15783 if !dara.IsNil(request.SourceDnsServer) {
15784 query["SourceDnsServer"] = request.SourceDnsServer
15785 }
15786
15787 if !dara.IsNil(request.SourceEdns) {
15788 query["SourceEdns"] = request.SourceEdns
15789 }
15790
15791 if !dara.IsNil(request.SourceProtocol) {
15792 query["SourceProtocol"] = request.SourceProtocol
15793 }
15794
15795 req := &openapiutil.OpenApiRequest{
15796 Query: openapiutil.Query(query),
15797 }
15798 params := &openapiutil.Params{
15799 Action: dara.String("UpdateDnsCacheDomain"),
15800 Version: dara.String("2015-01-09"),
15801 Protocol: dara.String("HTTPS"),
15802 Pathname: dara.String("/"),
15803 Method: dara.String("POST"),
15804 AuthType: dara.String("AK"),
15805 Style: dara.String("RPC"),
15806 ReqBodyType: dara.String("formData"),
15807 BodyType: dara.String("json"),
15808 }
15809 _result = &UpdateDnsCacheDomainResponse{}
15810 _body, _err := client.CallApi(params, req, runtime)
15811 if _err != nil {
15812 return _result, _err
15813 }
15814 _err = dara.Convert(_body, &_result)
15815 return _result, _err
15816 }
15817
15818 // Summary:
15819 //
15820 // Updates the cache-accelerated domain name based on the specified parameters.
15821 //
15822 // @param request - UpdateDnsCacheDomainRequest
15823 //
15824 // @return UpdateDnsCacheDomainResponse
15825 func UpdateDnsCacheDomain(client *Client, request *UpdateDnsCacheDomainRequest) (_result *UpdateDnsCacheDomainResponse, _err error) {
15826 runtime := &dara.RuntimeOptions{}
15827 _result = &UpdateDnsCacheDomainResponse{}
15828 _body, _err := UpdateDnsCacheDomainWithOptions(client,request, runtime)
15829 if _err != nil {
15830 return _result, _err
15831 }
15832 _result = _body
15833 return _result, _err
15834 }
15835
15836 // Summary:
15837 //
15838 // Updates the remarks for the cache-accelerated domain name of the destination domain name.
15839 //
15840 // @param request - UpdateDnsCacheDomainRemarkRequest
15841 //
15842 // @param runtime - runtime options for this request RuntimeOptions
15843 //
15844 // @return UpdateDnsCacheDomainRemarkResponse
15845 func UpdateDnsCacheDomainRemarkWithOptions(client *Client, request *UpdateDnsCacheDomainRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsCacheDomainRemarkResponse, _err error) {
15846 if dara.BoolValue(client.EnableValidate) == true {
15847 _err = request.Validate()
15848 if _err != nil {
15849 return _result, _err
15850 }
15851 }
15852 query := map[string]interface{}{}
15853 if !dara.IsNil(request.DomainName) {
15854 query["DomainName"] = request.DomainName
15855 }
15856
15857 if !dara.IsNil(request.Lang) {
15858 query["Lang"] = request.Lang
15859 }
15860
15861 if !dara.IsNil(request.Remark) {
15862 query["Remark"] = request.Remark
15863 }
15864
15865 req := &openapiutil.OpenApiRequest{
15866 Query: openapiutil.Query(query),
15867 }
15868 params := &openapiutil.Params{
15869 Action: dara.String("UpdateDnsCacheDomainRemark"),
15870 Version: dara.String("2015-01-09"),
15871 Protocol: dara.String("HTTPS"),
15872 Pathname: dara.String("/"),
15873 Method: dara.String("POST"),
15874 AuthType: dara.String("AK"),
15875 Style: dara.String("RPC"),
15876 ReqBodyType: dara.String("formData"),
15877 BodyType: dara.String("json"),
15878 }
15879 _result = &UpdateDnsCacheDomainRemarkResponse{}
15880 _body, _err := client.CallApi(params, req, runtime)
15881 if _err != nil {
15882 return _result, _err
15883 }
15884 _err = dara.Convert(_body, &_result)
15885 return _result, _err
15886 }
15887
15888 // Summary:
15889 //
15890 // Updates the remarks for the cache-accelerated domain name of the destination domain name.
15891 //
15892 // @param request - UpdateDnsCacheDomainRemarkRequest
15893 //
15894 // @return UpdateDnsCacheDomainRemarkResponse
15895 func UpdateDnsCacheDomainRemark(client *Client, request *UpdateDnsCacheDomainRemarkRequest) (_result *UpdateDnsCacheDomainRemarkResponse, _err error) {
15896 runtime := &dara.RuntimeOptions{}
15897 _result = &UpdateDnsCacheDomainRemarkResponse{}
15898 _body, _err := UpdateDnsCacheDomainRemarkWithOptions(client,request, runtime)
15899 if _err != nil {
15900 return _result, _err
15901 }
15902 _result = _body
15903 return _result, _err
15904 }
15905
15906 // Summary:
15907 //
15908 // Modifies an access policy.
15909 //
15910 // @param request - UpdateDnsGtmAccessStrategyRequest
15911 //
15912 // @param runtime - runtime options for this request RuntimeOptions
15913 //
15914 // @return UpdateDnsGtmAccessStrategyResponse
15915 func UpdateDnsGtmAccessStrategyWithOptions(client *Client, request *UpdateDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmAccessStrategyResponse, _err error) {
15916 if dara.BoolValue(client.EnableValidate) == true {
15917 _err = request.Validate()
15918 if _err != nil {
15919 return _result, _err
15920 }
15921 }
15922 query := map[string]interface{}{}
15923 if !dara.IsNil(request.AccessMode) {
15924 query["AccessMode"] = request.AccessMode
15925 }
15926
15927 if !dara.IsNil(request.DefaultAddrPool) {
15928 query["DefaultAddrPool"] = request.DefaultAddrPool
15929 }
15930
15931 if !dara.IsNil(request.DefaultAddrPoolType) {
15932 query["DefaultAddrPoolType"] = request.DefaultAddrPoolType
15933 }
15934
15935 if !dara.IsNil(request.DefaultLatencyOptimization) {
15936 query["DefaultLatencyOptimization"] = request.DefaultLatencyOptimization
15937 }
15938
15939 if !dara.IsNil(request.DefaultLbaStrategy) {
15940 query["DefaultLbaStrategy"] = request.DefaultLbaStrategy
15941 }
15942
15943 if !dara.IsNil(request.DefaultMaxReturnAddrNum) {
15944 query["DefaultMaxReturnAddrNum"] = request.DefaultMaxReturnAddrNum
15945 }
15946
15947 if !dara.IsNil(request.DefaultMinAvailableAddrNum) {
15948 query["DefaultMinAvailableAddrNum"] = request.DefaultMinAvailableAddrNum
15949 }
15950
15951 if !dara.IsNil(request.FailoverAddrPool) {
15952 query["FailoverAddrPool"] = request.FailoverAddrPool
15953 }
15954
15955 if !dara.IsNil(request.FailoverAddrPoolType) {
15956 query["FailoverAddrPoolType"] = request.FailoverAddrPoolType
15957 }
15958
15959 if !dara.IsNil(request.FailoverLatencyOptimization) {
15960 query["FailoverLatencyOptimization"] = request.FailoverLatencyOptimization
15961 }
15962
15963 if !dara.IsNil(request.FailoverLbaStrategy) {
15964 query["FailoverLbaStrategy"] = request.FailoverLbaStrategy
15965 }
15966
15967 if !dara.IsNil(request.FailoverMaxReturnAddrNum) {
15968 query["FailoverMaxReturnAddrNum"] = request.FailoverMaxReturnAddrNum
15969 }
15970
15971 if !dara.IsNil(request.FailoverMinAvailableAddrNum) {
15972 query["FailoverMinAvailableAddrNum"] = request.FailoverMinAvailableAddrNum
15973 }
15974
15975 if !dara.IsNil(request.Lang) {
15976 query["Lang"] = request.Lang
15977 }
15978
15979 if !dara.IsNil(request.Lines) {
15980 query["Lines"] = request.Lines
15981 }
15982
15983 if !dara.IsNil(request.StrategyId) {
15984 query["StrategyId"] = request.StrategyId
15985 }
15986
15987 if !dara.IsNil(request.StrategyName) {
15988 query["StrategyName"] = request.StrategyName
15989 }
15990
15991 req := &openapiutil.OpenApiRequest{
15992 Query: openapiutil.Query(query),
15993 }
15994 params := &openapiutil.Params{
15995 Action: dara.String("UpdateDnsGtmAccessStrategy"),
15996 Version: dara.String("2015-01-09"),
15997 Protocol: dara.String("HTTPS"),
15998 Pathname: dara.String("/"),
15999 Method: dara.String("POST"),
16000 AuthType: dara.String("AK"),
16001 Style: dara.String("RPC"),
16002 ReqBodyType: dara.String("formData"),
16003 BodyType: dara.String("json"),
16004 }
16005 _result = &UpdateDnsGtmAccessStrategyResponse{}
16006 _body, _err := client.CallApi(params, req, runtime)
16007 if _err != nil {
16008 return _result, _err
16009 }
16010 _err = dara.Convert(_body, &_result)
16011 return _result, _err
16012 }
16013
16014 // Summary:
16015 //
16016 // Modifies an access policy.
16017 //
16018 // @param request - UpdateDnsGtmAccessStrategyRequest
16019 //
16020 // @return UpdateDnsGtmAccessStrategyResponse
16021 func UpdateDnsGtmAccessStrategy(client *Client, request *UpdateDnsGtmAccessStrategyRequest) (_result *UpdateDnsGtmAccessStrategyResponse, _err error) {
16022 runtime := &dara.RuntimeOptions{}
16023 _result = &UpdateDnsGtmAccessStrategyResponse{}
16024 _body, _err := UpdateDnsGtmAccessStrategyWithOptions(client,request, runtime)
16025 if _err != nil {
16026 return _result, _err
16027 }
16028 _result = _body
16029 return _result, _err
16030 }
16031
16032 // Summary:
16033 //
16034 // Modifies an address pool.
16035 //
16036 // @param request - UpdateDnsGtmAddressPoolRequest
16037 //
16038 // @param runtime - runtime options for this request RuntimeOptions
16039 //
16040 // @return UpdateDnsGtmAddressPoolResponse
16041 func UpdateDnsGtmAddressPoolWithOptions(client *Client, request *UpdateDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmAddressPoolResponse, _err error) {
16042 if dara.BoolValue(client.EnableValidate) == true {
16043 _err = request.Validate()
16044 if _err != nil {
16045 return _result, _err
16046 }
16047 }
16048 query := map[string]interface{}{}
16049 if !dara.IsNil(request.Addr) {
16050 query["Addr"] = request.Addr
16051 }
16052
16053 if !dara.IsNil(request.AddrPoolId) {
16054 query["AddrPoolId"] = request.AddrPoolId
16055 }
16056
16057 if !dara.IsNil(request.Lang) {
16058 query["Lang"] = request.Lang
16059 }
16060
16061 if !dara.IsNil(request.LbaStrategy) {
16062 query["LbaStrategy"] = request.LbaStrategy
16063 }
16064
16065 if !dara.IsNil(request.Name) {
16066 query["Name"] = request.Name
16067 }
16068
16069 req := &openapiutil.OpenApiRequest{
16070 Query: openapiutil.Query(query),
16071 }
16072 params := &openapiutil.Params{
16073 Action: dara.String("UpdateDnsGtmAddressPool"),
16074 Version: dara.String("2015-01-09"),
16075 Protocol: dara.String("HTTPS"),
16076 Pathname: dara.String("/"),
16077 Method: dara.String("POST"),
16078 AuthType: dara.String("AK"),
16079 Style: dara.String("RPC"),
16080 ReqBodyType: dara.String("formData"),
16081 BodyType: dara.String("json"),
16082 }
16083 _result = &UpdateDnsGtmAddressPoolResponse{}
16084 _body, _err := client.CallApi(params, req, runtime)
16085 if _err != nil {
16086 return _result, _err
16087 }
16088 _err = dara.Convert(_body, &_result)
16089 return _result, _err
16090 }
16091
16092 // Summary:
16093 //
16094 // Modifies an address pool.
16095 //
16096 // @param request - UpdateDnsGtmAddressPoolRequest
16097 //
16098 // @return UpdateDnsGtmAddressPoolResponse
16099 func UpdateDnsGtmAddressPool(client *Client, request *UpdateDnsGtmAddressPoolRequest) (_result *UpdateDnsGtmAddressPoolResponse, _err error) {
16100 runtime := &dara.RuntimeOptions{}
16101 _result = &UpdateDnsGtmAddressPoolResponse{}
16102 _body, _err := UpdateDnsGtmAddressPoolWithOptions(client,request, runtime)
16103 if _err != nil {
16104 return _result, _err
16105 }
16106 _result = _body
16107 return _result, _err
16108 }
16109
16110 // Summary:
16111 //
16112 // Modifies the configurations of a Global Traffic Manager (GTM) instance.
16113 //
16114 // @param request - UpdateDnsGtmInstanceGlobalConfigRequest
16115 //
16116 // @param runtime - runtime options for this request RuntimeOptions
16117 //
16118 // @return UpdateDnsGtmInstanceGlobalConfigResponse
16119 func UpdateDnsGtmInstanceGlobalConfigWithOptions(client *Client, request *UpdateDnsGtmInstanceGlobalConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmInstanceGlobalConfigResponse, _err error) {
16120 if dara.BoolValue(client.EnableValidate) == true {
16121 _err = request.Validate()
16122 if _err != nil {
16123 return _result, _err
16124 }
16125 }
16126 query := map[string]interface{}{}
16127 if !dara.IsNil(request.AlertConfig) {
16128 query["AlertConfig"] = request.AlertConfig
16129 }
16130
16131 if !dara.IsNil(request.AlertGroup) {
16132 query["AlertGroup"] = request.AlertGroup
16133 }
16134
16135 if !dara.IsNil(request.CnameType) {
16136 query["CnameType"] = request.CnameType
16137 }
16138
16139 if !dara.IsNil(request.ForceUpdate) {
16140 query["ForceUpdate"] = request.ForceUpdate
16141 }
16142
16143 if !dara.IsNil(request.InstanceId) {
16144 query["InstanceId"] = request.InstanceId
16145 }
16146
16147 if !dara.IsNil(request.InstanceName) {
16148 query["InstanceName"] = request.InstanceName
16149 }
16150
16151 if !dara.IsNil(request.Lang) {
16152 query["Lang"] = request.Lang
16153 }
16154
16155 if !dara.IsNil(request.PublicCnameMode) {
16156 query["PublicCnameMode"] = request.PublicCnameMode
16157 }
16158
16159 if !dara.IsNil(request.PublicRr) {
16160 query["PublicRr"] = request.PublicRr
16161 }
16162
16163 if !dara.IsNil(request.PublicUserDomainName) {
16164 query["PublicUserDomainName"] = request.PublicUserDomainName
16165 }
16166
16167 if !dara.IsNil(request.PublicZoneName) {
16168 query["PublicZoneName"] = request.PublicZoneName
16169 }
16170
16171 if !dara.IsNil(request.Ttl) {
16172 query["Ttl"] = request.Ttl
16173 }
16174
16175 req := &openapiutil.OpenApiRequest{
16176 Query: openapiutil.Query(query),
16177 }
16178 params := &openapiutil.Params{
16179 Action: dara.String("UpdateDnsGtmInstanceGlobalConfig"),
16180 Version: dara.String("2015-01-09"),
16181 Protocol: dara.String("HTTPS"),
16182 Pathname: dara.String("/"),
16183 Method: dara.String("POST"),
16184 AuthType: dara.String("AK"),
16185 Style: dara.String("RPC"),
16186 ReqBodyType: dara.String("formData"),
16187 BodyType: dara.String("json"),
16188 }
16189 _result = &UpdateDnsGtmInstanceGlobalConfigResponse{}
16190 _body, _err := client.CallApi(params, req, runtime)
16191 if _err != nil {
16192 return _result, _err
16193 }
16194 _err = dara.Convert(_body, &_result)
16195 return _result, _err
16196 }
16197
16198 // Summary:
16199 //
16200 // Modifies the configurations of a Global Traffic Manager (GTM) instance.
16201 //
16202 // @param request - UpdateDnsGtmInstanceGlobalConfigRequest
16203 //
16204 // @return UpdateDnsGtmInstanceGlobalConfigResponse
16205 func UpdateDnsGtmInstanceGlobalConfig(client *Client, request *UpdateDnsGtmInstanceGlobalConfigRequest) (_result *UpdateDnsGtmInstanceGlobalConfigResponse, _err error) {
16206 runtime := &dara.RuntimeOptions{}
16207 _result = &UpdateDnsGtmInstanceGlobalConfigResponse{}
16208 _body, _err := UpdateDnsGtmInstanceGlobalConfigWithOptions(client,request, runtime)
16209 if _err != nil {
16210 return _result, _err
16211 }
16212 _result = _body
16213 return _result, _err
16214 }
16215
16216 // Summary:
16217 //
16218 // Modifies a health check task.
16219 //
16220 // @param request - UpdateDnsGtmMonitorRequest
16221 //
16222 // @param runtime - runtime options for this request RuntimeOptions
16223 //
16224 // @return UpdateDnsGtmMonitorResponse
16225 func UpdateDnsGtmMonitorWithOptions(client *Client, request *UpdateDnsGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmMonitorResponse, _err error) {
16226 if dara.BoolValue(client.EnableValidate) == true {
16227 _err = request.Validate()
16228 if _err != nil {
16229 return _result, _err
16230 }
16231 }
16232 query := map[string]interface{}{}
16233 if !dara.IsNil(request.EvaluationCount) {
16234 query["EvaluationCount"] = request.EvaluationCount
16235 }
16236
16237 if !dara.IsNil(request.Interval) {
16238 query["Interval"] = request.Interval
16239 }
16240
16241 if !dara.IsNil(request.IspCityNode) {
16242 query["IspCityNode"] = request.IspCityNode
16243 }
16244
16245 if !dara.IsNil(request.Lang) {
16246 query["Lang"] = request.Lang
16247 }
16248
16249 if !dara.IsNil(request.MonitorConfigId) {
16250 query["MonitorConfigId"] = request.MonitorConfigId
16251 }
16252
16253 if !dara.IsNil(request.MonitorExtendInfo) {
16254 query["MonitorExtendInfo"] = request.MonitorExtendInfo
16255 }
16256
16257 if !dara.IsNil(request.ProtocolType) {
16258 query["ProtocolType"] = request.ProtocolType
16259 }
16260
16261 if !dara.IsNil(request.Timeout) {
16262 query["Timeout"] = request.Timeout
16263 }
16264
16265 req := &openapiutil.OpenApiRequest{
16266 Query: openapiutil.Query(query),
16267 }
16268 params := &openapiutil.Params{
16269 Action: dara.String("UpdateDnsGtmMonitor"),
16270 Version: dara.String("2015-01-09"),
16271 Protocol: dara.String("HTTPS"),
16272 Pathname: dara.String("/"),
16273 Method: dara.String("POST"),
16274 AuthType: dara.String("AK"),
16275 Style: dara.String("RPC"),
16276 ReqBodyType: dara.String("formData"),
16277 BodyType: dara.String("json"),
16278 }
16279 _result = &UpdateDnsGtmMonitorResponse{}
16280 _body, _err := client.CallApi(params, req, runtime)
16281 if _err != nil {
16282 return _result, _err
16283 }
16284 _err = dara.Convert(_body, &_result)
16285 return _result, _err
16286 }
16287
16288 // Summary:
16289 //
16290 // Modifies a health check task.
16291 //
16292 // @param request - UpdateDnsGtmMonitorRequest
16293 //
16294 // @return UpdateDnsGtmMonitorResponse
16295 func UpdateDnsGtmMonitor(client *Client, request *UpdateDnsGtmMonitorRequest) (_result *UpdateDnsGtmMonitorResponse, _err error) {
16296 runtime := &dara.RuntimeOptions{}
16297 _result = &UpdateDnsGtmMonitorResponse{}
16298 _body, _err := UpdateDnsGtmMonitorWithOptions(client,request, runtime)
16299 if _err != nil {
16300 return _result, _err
16301 }
16302 _result = _body
16303 return _result, _err
16304 }
16305
16306 // Summary:
16307 //
16308 // Modifies the name of a domain name group based on the specified parameters.
16309 //
16310 // Description:
16311 //
16312 // Modifies the name of an existing domain name group.
16313 //
16314 // @param request - UpdateDomainGroupRequest
16315 //
16316 // @param runtime - runtime options for this request RuntimeOptions
16317 //
16318 // @return UpdateDomainGroupResponse
16319 func UpdateDomainGroupWithOptions(client *Client, request *UpdateDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainGroupResponse, _err error) {
16320 if dara.BoolValue(client.EnableValidate) == true {
16321 _err = request.Validate()
16322 if _err != nil {
16323 return _result, _err
16324 }
16325 }
16326 query := map[string]interface{}{}
16327 if !dara.IsNil(request.GroupId) {
16328 query["GroupId"] = request.GroupId
16329 }
16330
16331 if !dara.IsNil(request.GroupName) {
16332 query["GroupName"] = request.GroupName
16333 }
16334
16335 if !dara.IsNil(request.Lang) {
16336 query["Lang"] = request.Lang
16337 }
16338
16339 req := &openapiutil.OpenApiRequest{
16340 Query: openapiutil.Query(query),
16341 }
16342 params := &openapiutil.Params{
16343 Action: dara.String("UpdateDomainGroup"),
16344 Version: dara.String("2015-01-09"),
16345 Protocol: dara.String("HTTPS"),
16346 Pathname: dara.String("/"),
16347 Method: dara.String("POST"),
16348 AuthType: dara.String("AK"),
16349 Style: dara.String("RPC"),
16350 ReqBodyType: dara.String("formData"),
16351 BodyType: dara.String("json"),
16352 }
16353 _result = &UpdateDomainGroupResponse{}
16354 _body, _err := client.CallApi(params, req, runtime)
16355 if _err != nil {
16356 return _result, _err
16357 }
16358 _err = dara.Convert(_body, &_result)
16359 return _result, _err
16360 }
16361
16362 // Summary:
16363 //
16364 // Modifies the name of a domain name group based on the specified parameters.
16365 //
16366 // Description:
16367 //
16368 // Modifies the name of an existing domain name group.
16369 //
16370 // @param request - UpdateDomainGroupRequest
16371 //
16372 // @return UpdateDomainGroupResponse
16373 func UpdateDomainGroup(client *Client, request *UpdateDomainGroupRequest) (_result *UpdateDomainGroupResponse, _err error) {
16374 runtime := &dara.RuntimeOptions{}
16375 _result = &UpdateDomainGroupResponse{}
16376 _body, _err := UpdateDomainGroupWithOptions(client,request, runtime)
16377 if _err != nil {
16378 return _result, _err
16379 }
16380 _result = _body
16381 return _result, _err
16382 }
16383
16384 // Summary:
16385 //
16386 // Modifies a Domain Name System (DNS) record based on the specified parameters.
16387 //
16388 // @param request - UpdateDomainRecordRequest
16389 //
16390 // @param runtime - runtime options for this request RuntimeOptions
16391 //
16392 // @return UpdateDomainRecordResponse
16393 func UpdateDomainRecordWithOptions(client *Client, request *UpdateDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRecordResponse, _err error) {
16394 if dara.BoolValue(client.EnableValidate) == true {
16395 _err = request.Validate()
16396 if _err != nil {
16397 return _result, _err
16398 }
16399 }
16400 query := map[string]interface{}{}
16401 if !dara.IsNil(request.Lang) {
16402 query["Lang"] = request.Lang
16403 }
16404
16405 if !dara.IsNil(request.Line) {
16406 query["Line"] = request.Line
16407 }
16408
16409 if !dara.IsNil(request.Priority) {
16410 query["Priority"] = request.Priority
16411 }
16412
16413 if !dara.IsNil(request.RR) {
16414 query["RR"] = request.RR
16415 }
16416
16417 if !dara.IsNil(request.RecordId) {
16418 query["RecordId"] = request.RecordId
16419 }
16420
16421 if !dara.IsNil(request.TTL) {
16422 query["TTL"] = request.TTL
16423 }
16424
16425 if !dara.IsNil(request.Type) {
16426 query["Type"] = request.Type
16427 }
16428
16429 if !dara.IsNil(request.UserClientIp) {
16430 query["UserClientIp"] = request.UserClientIp
16431 }
16432
16433 if !dara.IsNil(request.Value) {
16434 query["Value"] = request.Value
16435 }
16436
16437 req := &openapiutil.OpenApiRequest{
16438 Query: openapiutil.Query(query),
16439 }
16440 params := &openapiutil.Params{
16441 Action: dara.String("UpdateDomainRecord"),
16442 Version: dara.String("2015-01-09"),
16443 Protocol: dara.String("HTTPS"),
16444 Pathname: dara.String("/"),
16445 Method: dara.String("POST"),
16446 AuthType: dara.String("AK"),
16447 Style: dara.String("RPC"),
16448 ReqBodyType: dara.String("formData"),
16449 BodyType: dara.String("json"),
16450 }
16451 _result = &UpdateDomainRecordResponse{}
16452 _body, _err := client.CallApi(params, req, runtime)
16453 if _err != nil {
16454 return _result, _err
16455 }
16456 _err = dara.Convert(_body, &_result)
16457 return _result, _err
16458 }
16459
16460 // Summary:
16461 //
16462 // Modifies a Domain Name System (DNS) record based on the specified parameters.
16463 //
16464 // @param request - UpdateDomainRecordRequest
16465 //
16466 // @return UpdateDomainRecordResponse
16467 func UpdateDomainRecord(client *Client, request *UpdateDomainRecordRequest) (_result *UpdateDomainRecordResponse, _err error) {
16468 runtime := &dara.RuntimeOptions{}
16469 _result = &UpdateDomainRecordResponse{}
16470 _body, _err := UpdateDomainRecordWithOptions(client,request, runtime)
16471 if _err != nil {
16472 return _result, _err
16473 }
16474 _result = _body
16475 return _result, _err
16476 }
16477
16478 // Summary:
16479 //
16480 // Modifies the description of a Domain Name System (DNS) record based on the specified parameters.
16481 //
16482 // @param request - UpdateDomainRecordRemarkRequest
16483 //
16484 // @param runtime - runtime options for this request RuntimeOptions
16485 //
16486 // @return UpdateDomainRecordRemarkResponse
16487 func UpdateDomainRecordRemarkWithOptions(client *Client, request *UpdateDomainRecordRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRecordRemarkResponse, _err error) {
16488 if dara.BoolValue(client.EnableValidate) == true {
16489 _err = request.Validate()
16490 if _err != nil {
16491 return _result, _err
16492 }
16493 }
16494 query := map[string]interface{}{}
16495 if !dara.IsNil(request.Lang) {
16496 query["Lang"] = request.Lang
16497 }
16498
16499 if !dara.IsNil(request.RecordId) {
16500 query["RecordId"] = request.RecordId
16501 }
16502
16503 if !dara.IsNil(request.Remark) {
16504 query["Remark"] = request.Remark
16505 }
16506
16507 if !dara.IsNil(request.UserClientIp) {
16508 query["UserClientIp"] = request.UserClientIp
16509 }
16510
16511 req := &openapiutil.OpenApiRequest{
16512 Query: openapiutil.Query(query),
16513 }
16514 params := &openapiutil.Params{
16515 Action: dara.String("UpdateDomainRecordRemark"),
16516 Version: dara.String("2015-01-09"),
16517 Protocol: dara.String("HTTPS"),
16518 Pathname: dara.String("/"),
16519 Method: dara.String("POST"),
16520 AuthType: dara.String("AK"),
16521 Style: dara.String("RPC"),
16522 ReqBodyType: dara.String("formData"),
16523 BodyType: dara.String("json"),
16524 }
16525 _result = &UpdateDomainRecordRemarkResponse{}
16526 _body, _err := client.CallApi(params, req, runtime)
16527 if _err != nil {
16528 return _result, _err
16529 }
16530 _err = dara.Convert(_body, &_result)
16531 return _result, _err
16532 }
16533
16534 // Summary:
16535 //
16536 // Modifies the description of a Domain Name System (DNS) record based on the specified parameters.
16537 //
16538 // @param request - UpdateDomainRecordRemarkRequest
16539 //
16540 // @return UpdateDomainRecordRemarkResponse
16541 func UpdateDomainRecordRemark(client *Client, request *UpdateDomainRecordRemarkRequest) (_result *UpdateDomainRecordRemarkResponse, _err error) {
16542 runtime := &dara.RuntimeOptions{}
16543 _result = &UpdateDomainRecordRemarkResponse{}
16544 _body, _err := UpdateDomainRecordRemarkWithOptions(client,request, runtime)
16545 if _err != nil {
16546 return _result, _err
16547 }
16548 _result = _body
16549 return _result, _err
16550 }
16551
16552 // Summary:
16553 //
16554 // Modifies the description of a domain name based on the specified parameters.
16555 //
16556 // @param request - UpdateDomainRemarkRequest
16557 //
16558 // @param runtime - runtime options for this request RuntimeOptions
16559 //
16560 // @return UpdateDomainRemarkResponse
16561 func UpdateDomainRemarkWithOptions(client *Client, request *UpdateDomainRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRemarkResponse, _err error) {
16562 if dara.BoolValue(client.EnableValidate) == true {
16563 _err = request.Validate()
16564 if _err != nil {
16565 return _result, _err
16566 }
16567 }
16568 query := map[string]interface{}{}
16569 if !dara.IsNil(request.DomainName) {
16570 query["DomainName"] = request.DomainName
16571 }
16572
16573 if !dara.IsNil(request.Lang) {
16574 query["Lang"] = request.Lang
16575 }
16576
16577 if !dara.IsNil(request.Remark) {
16578 query["Remark"] = request.Remark
16579 }
16580
16581 req := &openapiutil.OpenApiRequest{
16582 Query: openapiutil.Query(query),
16583 }
16584 params := &openapiutil.Params{
16585 Action: dara.String("UpdateDomainRemark"),
16586 Version: dara.String("2015-01-09"),
16587 Protocol: dara.String("HTTPS"),
16588 Pathname: dara.String("/"),
16589 Method: dara.String("POST"),
16590 AuthType: dara.String("AK"),
16591 Style: dara.String("RPC"),
16592 ReqBodyType: dara.String("formData"),
16593 BodyType: dara.String("json"),
16594 }
16595 _result = &UpdateDomainRemarkResponse{}
16596 _body, _err := client.CallApi(params, req, runtime)
16597 if _err != nil {
16598 return _result, _err
16599 }
16600 _err = dara.Convert(_body, &_result)
16601 return _result, _err
16602 }
16603
16604 // Summary:
16605 //
16606 // Modifies the description of a domain name based on the specified parameters.
16607 //
16608 // @param request - UpdateDomainRemarkRequest
16609 //
16610 // @return UpdateDomainRemarkResponse
16611 func UpdateDomainRemark(client *Client, request *UpdateDomainRemarkRequest) (_result *UpdateDomainRemarkResponse, _err error) {
16612 runtime := &dara.RuntimeOptions{}
16613 _result = &UpdateDomainRemarkResponse{}
16614 _body, _err := UpdateDomainRemarkWithOptions(client,request, runtime)
16615 if _err != nil {
16616 return _result, _err
16617 }
16618 _result = _body
16619 return _result, _err
16620 }
16621
16622 // @param request - UpdateGtmAccessStrategyRequest
16623 //
16624 // @param runtime - runtime options for this request RuntimeOptions
16625 //
16626 // @return UpdateGtmAccessStrategyResponse
16627 func UpdateGtmAccessStrategyWithOptions(client *Client, request *UpdateGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmAccessStrategyResponse, _err error) {
16628 if dara.BoolValue(client.EnableValidate) == true {
16629 _err = request.Validate()
16630 if _err != nil {
16631 return _result, _err
16632 }
16633 }
16634 query := map[string]interface{}{}
16635 if !dara.IsNil(request.AccessLines) {
16636 query["AccessLines"] = request.AccessLines
16637 }
16638
16639 if !dara.IsNil(request.DefaultAddrPoolId) {
16640 query["DefaultAddrPoolId"] = request.DefaultAddrPoolId
16641 }
16642
16643 if !dara.IsNil(request.FailoverAddrPoolId) {
16644 query["FailoverAddrPoolId"] = request.FailoverAddrPoolId
16645 }
16646
16647 if !dara.IsNil(request.Lang) {
16648 query["Lang"] = request.Lang
16649 }
16650
16651 if !dara.IsNil(request.StrategyId) {
16652 query["StrategyId"] = request.StrategyId
16653 }
16654
16655 if !dara.IsNil(request.StrategyName) {
16656 query["StrategyName"] = request.StrategyName
16657 }
16658
16659 req := &openapiutil.OpenApiRequest{
16660 Query: openapiutil.Query(query),
16661 }
16662 params := &openapiutil.Params{
16663 Action: dara.String("UpdateGtmAccessStrategy"),
16664 Version: dara.String("2015-01-09"),
16665 Protocol: dara.String("HTTPS"),
16666 Pathname: dara.String("/"),
16667 Method: dara.String("POST"),
16668 AuthType: dara.String("AK"),
16669 Style: dara.String("RPC"),
16670 ReqBodyType: dara.String("formData"),
16671 BodyType: dara.String("json"),
16672 }
16673 _result = &UpdateGtmAccessStrategyResponse{}
16674 _body, _err := client.CallApi(params, req, runtime)
16675 if _err != nil {
16676 return _result, _err
16677 }
16678 _err = dara.Convert(_body, &_result)
16679 return _result, _err
16680 }
16681
16682 // @param request - UpdateGtmAccessStrategyRequest
16683 //
16684 // @return UpdateGtmAccessStrategyResponse
16685 func UpdateGtmAccessStrategy(client *Client, request *UpdateGtmAccessStrategyRequest) (_result *UpdateGtmAccessStrategyResponse, _err error) {
16686 runtime := &dara.RuntimeOptions{}
16687 _result = &UpdateGtmAccessStrategyResponse{}
16688 _body, _err := UpdateGtmAccessStrategyWithOptions(client,request, runtime)
16689 if _err != nil {
16690 return _result, _err
16691 }
16692 _result = _body
16693 return _result, _err
16694 }
16695
16696 // @param request - UpdateGtmAddressPoolRequest
16697 //
16698 // @param runtime - runtime options for this request RuntimeOptions
16699 //
16700 // @return UpdateGtmAddressPoolResponse
16701 func UpdateGtmAddressPoolWithOptions(client *Client, request *UpdateGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmAddressPoolResponse, _err error) {
16702 if dara.BoolValue(client.EnableValidate) == true {
16703 _err = request.Validate()
16704 if _err != nil {
16705 return _result, _err
16706 }
16707 }
16708 query := map[string]interface{}{}
16709 if !dara.IsNil(request.Addr) {
16710 query["Addr"] = request.Addr
16711 }
16712
16713 if !dara.IsNil(request.AddrPoolId) {
16714 query["AddrPoolId"] = request.AddrPoolId
16715 }
16716
16717 if !dara.IsNil(request.Lang) {
16718 query["Lang"] = request.Lang
16719 }
16720
16721 if !dara.IsNil(request.MinAvailableAddrNum) {
16722 query["MinAvailableAddrNum"] = request.MinAvailableAddrNum
16723 }
16724
16725 if !dara.IsNil(request.Name) {
16726 query["Name"] = request.Name
16727 }
16728
16729 if !dara.IsNil(request.Type) {
16730 query["Type"] = request.Type
16731 }
16732
16733 req := &openapiutil.OpenApiRequest{
16734 Query: openapiutil.Query(query),
16735 }
16736 params := &openapiutil.Params{
16737 Action: dara.String("UpdateGtmAddressPool"),
16738 Version: dara.String("2015-01-09"),
16739 Protocol: dara.String("HTTPS"),
16740 Pathname: dara.String("/"),
16741 Method: dara.String("POST"),
16742 AuthType: dara.String("AK"),
16743 Style: dara.String("RPC"),
16744 ReqBodyType: dara.String("formData"),
16745 BodyType: dara.String("json"),
16746 }
16747 _result = &UpdateGtmAddressPoolResponse{}
16748 _body, _err := client.CallApi(params, req, runtime)
16749 if _err != nil {
16750 return _result, _err
16751 }
16752 _err = dara.Convert(_body, &_result)
16753 return _result, _err
16754 }
16755
16756 // @param request - UpdateGtmAddressPoolRequest
16757 //
16758 // @return UpdateGtmAddressPoolResponse
16759 func UpdateGtmAddressPool(client *Client, request *UpdateGtmAddressPoolRequest) (_result *UpdateGtmAddressPoolResponse, _err error) {
16760 runtime := &dara.RuntimeOptions{}
16761 _result = &UpdateGtmAddressPoolResponse{}
16762 _body, _err := UpdateGtmAddressPoolWithOptions(client,request, runtime)
16763 if _err != nil {
16764 return _result, _err
16765 }
16766 _result = _body
16767 return _result, _err
16768 }
16769
16770 // Summary:
16771 //
16772 // Modifies the configurations of a Global Traffic Manager (GTM) instance based on the specified parameters.
16773 //
16774 // @param request - UpdateGtmInstanceGlobalConfigRequest
16775 //
16776 // @param runtime - runtime options for this request RuntimeOptions
16777 //
16778 // @return UpdateGtmInstanceGlobalConfigResponse
16779 func UpdateGtmInstanceGlobalConfigWithOptions(client *Client, request *UpdateGtmInstanceGlobalConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmInstanceGlobalConfigResponse, _err error) {
16780 if dara.BoolValue(client.EnableValidate) == true {
16781 _err = request.Validate()
16782 if _err != nil {
16783 return _result, _err
16784 }
16785 }
16786 query := map[string]interface{}{}
16787 if !dara.IsNil(request.AlertGroup) {
16788 query["AlertGroup"] = request.AlertGroup
16789 }
16790
16791 if !dara.IsNil(request.CnameCustomDomainName) {
16792 query["CnameCustomDomainName"] = request.CnameCustomDomainName
16793 }
16794
16795 if !dara.IsNil(request.CnameMode) {
16796 query["CnameMode"] = request.CnameMode
16797 }
16798
16799 if !dara.IsNil(request.InstanceId) {
16800 query["InstanceId"] = request.InstanceId
16801 }
16802
16803 if !dara.IsNil(request.InstanceName) {
16804 query["InstanceName"] = request.InstanceName
16805 }
16806
16807 if !dara.IsNil(request.Lang) {
16808 query["Lang"] = request.Lang
16809 }
16810
16811 if !dara.IsNil(request.LbaStrategy) {
16812 query["LbaStrategy"] = request.LbaStrategy
16813 }
16814
16815 if !dara.IsNil(request.Ttl) {
16816 query["Ttl"] = request.Ttl
16817 }
16818
16819 if !dara.IsNil(request.UserDomainName) {
16820 query["UserDomainName"] = request.UserDomainName
16821 }
16822
16823 req := &openapiutil.OpenApiRequest{
16824 Query: openapiutil.Query(query),
16825 }
16826 params := &openapiutil.Params{
16827 Action: dara.String("UpdateGtmInstanceGlobalConfig"),
16828 Version: dara.String("2015-01-09"),
16829 Protocol: dara.String("HTTPS"),
16830 Pathname: dara.String("/"),
16831 Method: dara.String("POST"),
16832 AuthType: dara.String("AK"),
16833 Style: dara.String("RPC"),
16834 ReqBodyType: dara.String("formData"),
16835 BodyType: dara.String("json"),
16836 }
16837 _result = &UpdateGtmInstanceGlobalConfigResponse{}
16838 _body, _err := client.CallApi(params, req, runtime)
16839 if _err != nil {
16840 return _result, _err
16841 }
16842 _err = dara.Convert(_body, &_result)
16843 return _result, _err
16844 }
16845
16846 // Summary:
16847 //
16848 // Modifies the configurations of a Global Traffic Manager (GTM) instance based on the specified parameters.
16849 //
16850 // @param request - UpdateGtmInstanceGlobalConfigRequest
16851 //
16852 // @return UpdateGtmInstanceGlobalConfigResponse
16853 func UpdateGtmInstanceGlobalConfig(client *Client, request *UpdateGtmInstanceGlobalConfigRequest) (_result *UpdateGtmInstanceGlobalConfigResponse, _err error) {
16854 runtime := &dara.RuntimeOptions{}
16855 _result = &UpdateGtmInstanceGlobalConfigResponse{}
16856 _body, _err := UpdateGtmInstanceGlobalConfigWithOptions(client,request, runtime)
16857 if _err != nil {
16858 return _result, _err
16859 }
16860 _result = _body
16861 return _result, _err
16862 }
16863
16864 // Summary:
16865 //
16866 // Modifies the health check configuration for an address pool of a Global Traffic Manager (GTM) instance.
16867 //
16868 // @param request - UpdateGtmMonitorRequest
16869 //
16870 // @param runtime - runtime options for this request RuntimeOptions
16871 //
16872 // @return UpdateGtmMonitorResponse
16873 func UpdateGtmMonitorWithOptions(client *Client, request *UpdateGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmMonitorResponse, _err error) {
16874 if dara.BoolValue(client.EnableValidate) == true {
16875 _err = request.Validate()
16876 if _err != nil {
16877 return _result, _err
16878 }
16879 }
16880 query := map[string]interface{}{}
16881 if !dara.IsNil(request.EvaluationCount) {
16882 query["EvaluationCount"] = request.EvaluationCount
16883 }
16884
16885 if !dara.IsNil(request.Interval) {
16886 query["Interval"] = request.Interval
16887 }
16888
16889 if !dara.IsNil(request.IspCityNode) {
16890 query["IspCityNode"] = request.IspCityNode
16891 }
16892
16893 if !dara.IsNil(request.Lang) {
16894 query["Lang"] = request.Lang
16895 }
16896
16897 if !dara.IsNil(request.MonitorConfigId) {
16898 query["MonitorConfigId"] = request.MonitorConfigId
16899 }
16900
16901 if !dara.IsNil(request.MonitorExtendInfo) {
16902 query["MonitorExtendInfo"] = request.MonitorExtendInfo
16903 }
16904
16905 if !dara.IsNil(request.ProtocolType) {
16906 query["ProtocolType"] = request.ProtocolType
16907 }
16908
16909 if !dara.IsNil(request.Timeout) {
16910 query["Timeout"] = request.Timeout
16911 }
16912
16913 req := &openapiutil.OpenApiRequest{
16914 Query: openapiutil.Query(query),
16915 }
16916 params := &openapiutil.Params{
16917 Action: dara.String("UpdateGtmMonitor"),
16918 Version: dara.String("2015-01-09"),
16919 Protocol: dara.String("HTTPS"),
16920 Pathname: dara.String("/"),
16921 Method: dara.String("POST"),
16922 AuthType: dara.String("AK"),
16923 Style: dara.String("RPC"),
16924 ReqBodyType: dara.String("formData"),
16925 BodyType: dara.String("json"),
16926 }
16927 _result = &UpdateGtmMonitorResponse{}
16928 _body, _err := client.CallApi(params, req, runtime)
16929 if _err != nil {
16930 return _result, _err
16931 }
16932 _err = dara.Convert(_body, &_result)
16933 return _result, _err
16934 }
16935
16936 // Summary:
16937 //
16938 // Modifies the health check configuration for an address pool of a Global Traffic Manager (GTM) instance.
16939 //
16940 // @param request - UpdateGtmMonitorRequest
16941 //
16942 // @return UpdateGtmMonitorResponse
16943 func UpdateGtmMonitor(client *Client, request *UpdateGtmMonitorRequest) (_result *UpdateGtmMonitorResponse, _err error) {
16944 runtime := &dara.RuntimeOptions{}
16945 _result = &UpdateGtmMonitorResponse{}
16946 _body, _err := UpdateGtmMonitorWithOptions(client,request, runtime)
16947 if _err != nil {
16948 return _result, _err
16949 }
16950 _result = _body
16951 return _result, _err
16952 }
16953
16954 // Summary:
16955 //
16956 // Modifies a disaster recovery plan.
16957 //
16958 // @param request - UpdateGtmRecoveryPlanRequest
16959 //
16960 // @param runtime - runtime options for this request RuntimeOptions
16961 //
16962 // @return UpdateGtmRecoveryPlanResponse
16963 func UpdateGtmRecoveryPlanWithOptions(client *Client, request *UpdateGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmRecoveryPlanResponse, _err error) {
16964 if dara.BoolValue(client.EnableValidate) == true {
16965 _err = request.Validate()
16966 if _err != nil {
16967 return _result, _err
16968 }
16969 }
16970 query := map[string]interface{}{}
16971 if !dara.IsNil(request.FaultAddrPool) {
16972 query["FaultAddrPool"] = request.FaultAddrPool
16973 }
16974
16975 if !dara.IsNil(request.Lang) {
16976 query["Lang"] = request.Lang
16977 }
16978
16979 if !dara.IsNil(request.Name) {
16980 query["Name"] = request.Name
16981 }
16982
16983 if !dara.IsNil(request.RecoveryPlanId) {
16984 query["RecoveryPlanId"] = request.RecoveryPlanId
16985 }
16986
16987 if !dara.IsNil(request.Remark) {
16988 query["Remark"] = request.Remark
16989 }
16990
16991 req := &openapiutil.OpenApiRequest{
16992 Query: openapiutil.Query(query),
16993 }
16994 params := &openapiutil.Params{
16995 Action: dara.String("UpdateGtmRecoveryPlan"),
16996 Version: dara.String("2015-01-09"),
16997 Protocol: dara.String("HTTPS"),
16998 Pathname: dara.String("/"),
16999 Method: dara.String("POST"),
17000 AuthType: dara.String("AK"),
17001 Style: dara.String("RPC"),
17002 ReqBodyType: dara.String("formData"),
17003 BodyType: dara.String("json"),
17004 }
17005 _result = &UpdateGtmRecoveryPlanResponse{}
17006 _body, _err := client.CallApi(params, req, runtime)
17007 if _err != nil {
17008 return _result, _err
17009 }
17010 _err = dara.Convert(_body, &_result)
17011 return _result, _err
17012 }
17013
17014 // Summary:
17015 //
17016 // Modifies a disaster recovery plan.
17017 //
17018 // @param request - UpdateGtmRecoveryPlanRequest
17019 //
17020 // @return UpdateGtmRecoveryPlanResponse
17021 func UpdateGtmRecoveryPlan(client *Client, request *UpdateGtmRecoveryPlanRequest) (_result *UpdateGtmRecoveryPlanResponse, _err error) {
17022 runtime := &dara.RuntimeOptions{}
17023 _result = &UpdateGtmRecoveryPlanResponse{}
17024 _body, _err := UpdateGtmRecoveryPlanWithOptions(client,request, runtime)
17025 if _err != nil {
17026 return _result, _err
17027 }
17028 _result = _body
17029 return _result, _err
17030 }
17031
17032 // Summary:
17033 //
17034 // 修改缓存刷新套餐包配置
17035 //
17036 // @param request - UpdateIspFlushCacheInstanceConfigRequest
17037 //
17038 // @param runtime - runtime options for this request RuntimeOptions
17039 //
17040 // @return UpdateIspFlushCacheInstanceConfigResponse
17041 func UpdateIspFlushCacheInstanceConfigWithOptions(client *Client, request *UpdateIspFlushCacheInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateIspFlushCacheInstanceConfigResponse, _err error) {
17042 if dara.BoolValue(client.EnableValidate) == true {
17043 _err = request.Validate()
17044 if _err != nil {
17045 return _result, _err
17046 }
17047 }
17048 query := map[string]interface{}{}
17049 if !dara.IsNil(request.InstanceId) {
17050 query["InstanceId"] = request.InstanceId
17051 }
17052
17053 if !dara.IsNil(request.InstanceName) {
17054 query["InstanceName"] = request.InstanceName
17055 }
17056
17057 if !dara.IsNil(request.Lang) {
17058 query["Lang"] = request.Lang
17059 }
17060
17061 req := &openapiutil.OpenApiRequest{
17062 Query: openapiutil.Query(query),
17063 }
17064 params := &openapiutil.Params{
17065 Action: dara.String("UpdateIspFlushCacheInstanceConfig"),
17066 Version: dara.String("2015-01-09"),
17067 Protocol: dara.String("HTTPS"),
17068 Pathname: dara.String("/"),
17069 Method: dara.String("POST"),
17070 AuthType: dara.String("AK"),
17071 Style: dara.String("RPC"),
17072 ReqBodyType: dara.String("formData"),
17073 BodyType: dara.String("json"),
17074 }
17075 _result = &UpdateIspFlushCacheInstanceConfigResponse{}
17076 _body, _err := client.CallApi(params, req, runtime)
17077 if _err != nil {
17078 return _result, _err
17079 }
17080 _err = dara.Convert(_body, &_result)
17081 return _result, _err
17082 }
17083
17084 // Summary:
17085 //
17086 // 修改缓存刷新套餐包配置
17087 //
17088 // @param request - UpdateIspFlushCacheInstanceConfigRequest
17089 //
17090 // @return UpdateIspFlushCacheInstanceConfigResponse
17091 func UpdateIspFlushCacheInstanceConfig(client *Client, request *UpdateIspFlushCacheInstanceConfigRequest) (_result *UpdateIspFlushCacheInstanceConfigResponse, _err error) {
17092 runtime := &dara.RuntimeOptions{}
17093 _result = &UpdateIspFlushCacheInstanceConfigResponse{}
17094 _body, _err := UpdateIspFlushCacheInstanceConfigWithOptions(client,request, runtime)
17095 if _err != nil {
17096 return _result, _err
17097 }
17098 _result = _body
17099 return _result, _err
17100 }
17101
17102 // Summary:
17103 //
17104 // 修改递归解析内置权威解析记录
17105 //
17106 // @param request - UpdateRecursionRecordRequest
17107 //
17108 // @param runtime - runtime options for this request RuntimeOptions
17109 //
17110 // @return UpdateRecursionRecordResponse
17111 func UpdateRecursionRecordWithOptions(client *Client, request *UpdateRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordResponse, _err error) {
17112 if dara.BoolValue(client.EnableValidate) == true {
17113 _err = request.Validate()
17114 if _err != nil {
17115 return _result, _err
17116 }
17117 }
17118 query := map[string]interface{}{}
17119 if !dara.IsNil(request.ClientToken) {
17120 query["ClientToken"] = request.ClientToken
17121 }
17122
17123 if !dara.IsNil(request.Priority) {
17124 query["Priority"] = request.Priority
17125 }
17126
17127 if !dara.IsNil(request.RecordId) {
17128 query["RecordId"] = request.RecordId
17129 }
17130
17131 if !dara.IsNil(request.RequestSource) {
17132 query["RequestSource"] = request.RequestSource
17133 }
17134
17135 if !dara.IsNil(request.Rr) {
17136 query["Rr"] = request.Rr
17137 }
17138
17139 if !dara.IsNil(request.Ttl) {
17140 query["Ttl"] = request.Ttl
17141 }
17142
17143 if !dara.IsNil(request.Type) {
17144 query["Type"] = request.Type
17145 }
17146
17147 if !dara.IsNil(request.Value) {
17148 query["Value"] = request.Value
17149 }
17150
17151 if !dara.IsNil(request.Weight) {
17152 query["Weight"] = request.Weight
17153 }
17154
17155 req := &openapiutil.OpenApiRequest{
17156 Query: openapiutil.Query(query),
17157 }
17158 params := &openapiutil.Params{
17159 Action: dara.String("UpdateRecursionRecord"),
17160 Version: dara.String("2015-01-09"),
17161 Protocol: dara.String("HTTPS"),
17162 Pathname: dara.String("/"),
17163 Method: dara.String("POST"),
17164 AuthType: dara.String("AK"),
17165 Style: dara.String("RPC"),
17166 ReqBodyType: dara.String("formData"),
17167 BodyType: dara.String("json"),
17168 }
17169 _result = &UpdateRecursionRecordResponse{}
17170 _body, _err := client.CallApi(params, req, runtime)
17171 if _err != nil {
17172 return _result, _err
17173 }
17174 _err = dara.Convert(_body, &_result)
17175 return _result, _err
17176 }
17177
17178 // Summary:
17179 //
17180 // 修改递归解析内置权威解析记录
17181 //
17182 // @param request - UpdateRecursionRecordRequest
17183 //
17184 // @return UpdateRecursionRecordResponse
17185 func UpdateRecursionRecord(client *Client, request *UpdateRecursionRecordRequest) (_result *UpdateRecursionRecordResponse, _err error) {
17186 runtime := &dara.RuntimeOptions{}
17187 _result = &UpdateRecursionRecordResponse{}
17188 _body, _err := UpdateRecursionRecordWithOptions(client,request, runtime)
17189 if _err != nil {
17190 return _result, _err
17191 }
17192 _result = _body
17193 return _result, _err
17194 }
17195
17196 // Summary:
17197 //
17198 // 修改内置权威解析记录启用状态
17199 //
17200 // @param request - UpdateRecursionRecordEnableStatusRequest
17201 //
17202 // @param runtime - runtime options for this request RuntimeOptions
17203 //
17204 // @return UpdateRecursionRecordEnableStatusResponse
17205 func UpdateRecursionRecordEnableStatusWithOptions(client *Client, request *UpdateRecursionRecordEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordEnableStatusResponse, _err error) {
17206 if dara.BoolValue(client.EnableValidate) == true {
17207 _err = request.Validate()
17208 if _err != nil {
17209 return _result, _err
17210 }
17211 }
17212 query := map[string]interface{}{}
17213 if !dara.IsNil(request.ClientToken) {
17214 query["ClientToken"] = request.ClientToken
17215 }
17216
17217 if !dara.IsNil(request.EnableStatus) {
17218 query["EnableStatus"] = request.EnableStatus
17219 }
17220
17221 if !dara.IsNil(request.RecordId) {
17222 query["RecordId"] = request.RecordId
17223 }
17224
17225 req := &openapiutil.OpenApiRequest{
17226 Query: openapiutil.Query(query),
17227 }
17228 params := &openapiutil.Params{
17229 Action: dara.String("UpdateRecursionRecordEnableStatus"),
17230 Version: dara.String("2015-01-09"),
17231 Protocol: dara.String("HTTPS"),
17232 Pathname: dara.String("/"),
17233 Method: dara.String("POST"),
17234 AuthType: dara.String("AK"),
17235 Style: dara.String("RPC"),
17236 ReqBodyType: dara.String("formData"),
17237 BodyType: dara.String("json"),
17238 }
17239 _result = &UpdateRecursionRecordEnableStatusResponse{}
17240 _body, _err := client.CallApi(params, req, runtime)
17241 if _err != nil {
17242 return _result, _err
17243 }
17244 _err = dara.Convert(_body, &_result)
17245 return _result, _err
17246 }
17247
17248 // Summary:
17249 //
17250 // 修改内置权威解析记录启用状态
17251 //
17252 // @param request - UpdateRecursionRecordEnableStatusRequest
17253 //
17254 // @return UpdateRecursionRecordEnableStatusResponse
17255 func UpdateRecursionRecordEnableStatus(client *Client, request *UpdateRecursionRecordEnableStatusRequest) (_result *UpdateRecursionRecordEnableStatusResponse, _err error) {
17256 runtime := &dara.RuntimeOptions{}
17257 _result = &UpdateRecursionRecordEnableStatusResponse{}
17258 _body, _err := UpdateRecursionRecordEnableStatusWithOptions(client,request, runtime)
17259 if _err != nil {
17260 return _result, _err
17261 }
17262 _result = _body
17263 return _result, _err
17264 }
17265
17266 // Summary:
17267 //
17268 // 修改递归解析内置权威解析记录备注
17269 //
17270 // @param request - UpdateRecursionRecordRemarkRequest
17271 //
17272 // @param runtime - runtime options for this request RuntimeOptions
17273 //
17274 // @return UpdateRecursionRecordRemarkResponse
17275 func UpdateRecursionRecordRemarkWithOptions(client *Client, request *UpdateRecursionRecordRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordRemarkResponse, _err error) {
17276 if dara.BoolValue(client.EnableValidate) == true {
17277 _err = request.Validate()
17278 if _err != nil {
17279 return _result, _err
17280 }
17281 }
17282 query := map[string]interface{}{}
17283 if !dara.IsNil(request.ClientToken) {
17284 query["ClientToken"] = request.ClientToken
17285 }
17286
17287 if !dara.IsNil(request.RecordId) {
17288 query["RecordId"] = request.RecordId
17289 }
17290
17291 if !dara.IsNil(request.Remark) {
17292 query["Remark"] = request.Remark
17293 }
17294
17295 req := &openapiutil.OpenApiRequest{
17296 Query: openapiutil.Query(query),
17297 }
17298 params := &openapiutil.Params{
17299 Action: dara.String("UpdateRecursionRecordRemark"),
17300 Version: dara.String("2015-01-09"),
17301 Protocol: dara.String("HTTPS"),
17302 Pathname: dara.String("/"),
17303 Method: dara.String("POST"),
17304 AuthType: dara.String("AK"),
17305 Style: dara.String("RPC"),
17306 ReqBodyType: dara.String("formData"),
17307 BodyType: dara.String("json"),
17308 }
17309 _result = &UpdateRecursionRecordRemarkResponse{}
17310 _body, _err := client.CallApi(params, req, runtime)
17311 if _err != nil {
17312 return _result, _err
17313 }
17314 _err = dara.Convert(_body, &_result)
17315 return _result, _err
17316 }
17317
17318 // Summary:
17319 //
17320 // 修改递归解析内置权威解析记录备注
17321 //
17322 // @param request - UpdateRecursionRecordRemarkRequest
17323 //
17324 // @return UpdateRecursionRecordRemarkResponse
17325 func UpdateRecursionRecordRemark(client *Client, request *UpdateRecursionRecordRemarkRequest) (_result *UpdateRecursionRecordRemarkResponse, _err error) {
17326 runtime := &dara.RuntimeOptions{}
17327 _result = &UpdateRecursionRecordRemarkResponse{}
17328 _body, _err := UpdateRecursionRecordRemarkWithOptions(client,request, runtime)
17329 if _err != nil {
17330 return _result, _err
17331 }
17332 _result = _body
17333 return _result, _err
17334 }
17335
17336 // Summary:
17337 //
17338 // 修改递归解析内置权威解析记录权重
17339 //
17340 // @param request - UpdateRecursionRecordWeightRequest
17341 //
17342 // @param runtime - runtime options for this request RuntimeOptions
17343 //
17344 // @return UpdateRecursionRecordWeightResponse
17345 func UpdateRecursionRecordWeightWithOptions(client *Client, request *UpdateRecursionRecordWeightRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordWeightResponse, _err error) {
17346 if dara.BoolValue(client.EnableValidate) == true {
17347 _err = request.Validate()
17348 if _err != nil {
17349 return _result, _err
17350 }
17351 }
17352 query := map[string]interface{}{}
17353 if !dara.IsNil(request.ClientToken) {
17354 query["ClientToken"] = request.ClientToken
17355 }
17356
17357 if !dara.IsNil(request.RecordId) {
17358 query["RecordId"] = request.RecordId
17359 }
17360
17361 if !dara.IsNil(request.Weight) {
17362 query["Weight"] = request.Weight
17363 }
17364
17365 req := &openapiutil.OpenApiRequest{
17366 Query: openapiutil.Query(query),
17367 }
17368 params := &openapiutil.Params{
17369 Action: dara.String("UpdateRecursionRecordWeight"),
17370 Version: dara.String("2015-01-09"),
17371 Protocol: dara.String("HTTPS"),
17372 Pathname: dara.String("/"),
17373 Method: dara.String("POST"),
17374 AuthType: dara.String("AK"),
17375 Style: dara.String("RPC"),
17376 ReqBodyType: dara.String("formData"),
17377 BodyType: dara.String("json"),
17378 }
17379 _result = &UpdateRecursionRecordWeightResponse{}
17380 _body, _err := client.CallApi(params, req, runtime)
17381 if _err != nil {
17382 return _result, _err
17383 }
17384 _err = dara.Convert(_body, &_result)
17385 return _result, _err
17386 }
17387
17388 // Summary:
17389 //
17390 // 修改递归解析内置权威解析记录权重
17391 //
17392 // @param request - UpdateRecursionRecordWeightRequest
17393 //
17394 // @return UpdateRecursionRecordWeightResponse
17395 func UpdateRecursionRecordWeight(client *Client, request *UpdateRecursionRecordWeightRequest) (_result *UpdateRecursionRecordWeightResponse, _err error) {
17396 runtime := &dara.RuntimeOptions{}
17397 _result = &UpdateRecursionRecordWeightResponse{}
17398 _body, _err := UpdateRecursionRecordWeightWithOptions(client,request, runtime)
17399 if _err != nil {
17400 return _result, _err
17401 }
17402 _result = _body
17403 return _result, _err
17404 }
17405
17406 // Summary:
17407 //
17408 // 修改递归解析内置权威解析记录权重算法启用状态
17409 //
17410 // @param request - UpdateRecursionRecordWeightEnableStatusRequest
17411 //
17412 // @param runtime - runtime options for this request RuntimeOptions
17413 //
17414 // @return UpdateRecursionRecordWeightEnableStatusResponse
17415 func UpdateRecursionRecordWeightEnableStatusWithOptions(client *Client, request *UpdateRecursionRecordWeightEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordWeightEnableStatusResponse, _err error) {
17416 if dara.BoolValue(client.EnableValidate) == true {
17417 _err = request.Validate()
17418 if _err != nil {
17419 return _result, _err
17420 }
17421 }
17422 query := map[string]interface{}{}
17423 if !dara.IsNil(request.ClientToken) {
17424 query["ClientToken"] = request.ClientToken
17425 }
17426
17427 if !dara.IsNil(request.EnableStatus) {
17428 query["EnableStatus"] = request.EnableStatus
17429 }
17430
17431 if !dara.IsNil(request.RequestSource) {
17432 query["RequestSource"] = request.RequestSource
17433 }
17434
17435 if !dara.IsNil(request.Rr) {
17436 query["Rr"] = request.Rr
17437 }
17438
17439 if !dara.IsNil(request.Type) {
17440 query["Type"] = request.Type
17441 }
17442
17443 if !dara.IsNil(request.ZoneId) {
17444 query["ZoneId"] = request.ZoneId
17445 }
17446
17447 req := &openapiutil.OpenApiRequest{
17448 Query: openapiutil.Query(query),
17449 }
17450 params := &openapiutil.Params{
17451 Action: dara.String("UpdateRecursionRecordWeightEnableStatus"),
17452 Version: dara.String("2015-01-09"),
17453 Protocol: dara.String("HTTPS"),
17454 Pathname: dara.String("/"),
17455 Method: dara.String("POST"),
17456 AuthType: dara.String("AK"),
17457 Style: dara.String("RPC"),
17458 ReqBodyType: dara.String("formData"),
17459 BodyType: dara.String("json"),
17460 }
17461 _result = &UpdateRecursionRecordWeightEnableStatusResponse{}
17462 _body, _err := client.CallApi(params, req, runtime)
17463 if _err != nil {
17464 return _result, _err
17465 }
17466 _err = dara.Convert(_body, &_result)
17467 return _result, _err
17468 }
17469
17470 // Summary:
17471 //
17472 // 修改递归解析内置权威解析记录权重算法启用状态
17473 //
17474 // @param request - UpdateRecursionRecordWeightEnableStatusRequest
17475 //
17476 // @return UpdateRecursionRecordWeightEnableStatusResponse
17477 func UpdateRecursionRecordWeightEnableStatus(client *Client, request *UpdateRecursionRecordWeightEnableStatusRequest) (_result *UpdateRecursionRecordWeightEnableStatusResponse, _err error) {
17478 runtime := &dara.RuntimeOptions{}
17479 _result = &UpdateRecursionRecordWeightEnableStatusResponse{}
17480 _body, _err := UpdateRecursionRecordWeightEnableStatusWithOptions(client,request, runtime)
17481 if _err != nil {
17482 return _result, _err
17483 }
17484 _result = _body
17485 return _result, _err
17486 }
17487
17488 // Summary:
17489 //
17490 // 修改递归解析内置权威域名zone生效范围
17491 //
17492 // @param tmpReq - UpdateRecursionZoneEffectiveScopeRequest
17493 //
17494 // @param runtime - runtime options for this request RuntimeOptions
17495 //
17496 // @return UpdateRecursionZoneEffectiveScopeResponse
17497 func UpdateRecursionZoneEffectiveScopeWithOptions(client *Client, tmpReq *UpdateRecursionZoneEffectiveScopeRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneEffectiveScopeResponse, _err error) {
17498 if dara.BoolValue(client.EnableValidate) == true {
17499 _err = tmpReq.Validate()
17500 if _err != nil {
17501 return _result, _err
17502 }
17503 }
17504 request := &UpdateRecursionZoneEffectiveScopeShrinkRequest{}
17505 openapiutil.Convert(tmpReq, request)
17506 if !dara.IsNil(tmpReq.EffectiveScopes) {
17507 request.EffectiveScopesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.EffectiveScopes, dara.String("EffectiveScopes"), dara.String("json"))
17508 }
17509
17510 query := map[string]interface{}{}
17511 if !dara.IsNil(request.ClientToken) {
17512 query["ClientToken"] = request.ClientToken
17513 }
17514
17515 if !dara.IsNil(request.EffectiveScopesShrink) {
17516 query["EffectiveScopes"] = request.EffectiveScopesShrink
17517 }
17518
17519 if !dara.IsNil(request.ZoneId) {
17520 query["ZoneId"] = request.ZoneId
17521 }
17522
17523 req := &openapiutil.OpenApiRequest{
17524 Query: openapiutil.Query(query),
17525 }
17526 params := &openapiutil.Params{
17527 Action: dara.String("UpdateRecursionZoneEffectiveScope"),
17528 Version: dara.String("2015-01-09"),
17529 Protocol: dara.String("HTTPS"),
17530 Pathname: dara.String("/"),
17531 Method: dara.String("POST"),
17532 AuthType: dara.String("AK"),
17533 Style: dara.String("RPC"),
17534 ReqBodyType: dara.String("formData"),
17535 BodyType: dara.String("json"),
17536 }
17537 _result = &UpdateRecursionZoneEffectiveScopeResponse{}
17538 _body, _err := client.CallApi(params, req, runtime)
17539 if _err != nil {
17540 return _result, _err
17541 }
17542 _err = dara.Convert(_body, &_result)
17543 return _result, _err
17544 }
17545
17546 // Summary:
17547 //
17548 // 修改递归解析内置权威域名zone生效范围
17549 //
17550 // @param request - UpdateRecursionZoneEffectiveScopeRequest
17551 //
17552 // @return UpdateRecursionZoneEffectiveScopeResponse
17553 func UpdateRecursionZoneEffectiveScope(client *Client, request *UpdateRecursionZoneEffectiveScopeRequest) (_result *UpdateRecursionZoneEffectiveScopeResponse, _err error) {
17554 runtime := &dara.RuntimeOptions{}
17555 _result = &UpdateRecursionZoneEffectiveScopeResponse{}
17556 _body, _err := UpdateRecursionZoneEffectiveScopeWithOptions(client,request, runtime)
17557 if _err != nil {
17558 return _result, _err
17559 }
17560 _result = _body
17561 return _result, _err
17562 }
17563
17564 // Summary:
17565 //
17566 // 修改递归解析内置权威域名zone递归代理模式
17567 //
17568 // @param request - UpdateRecursionZoneProxyPatternRequest
17569 //
17570 // @param runtime - runtime options for this request RuntimeOptions
17571 //
17572 // @return UpdateRecursionZoneProxyPatternResponse
17573 func UpdateRecursionZoneProxyPatternWithOptions(client *Client, request *UpdateRecursionZoneProxyPatternRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneProxyPatternResponse, _err error) {
17574 if dara.BoolValue(client.EnableValidate) == true {
17575 _err = request.Validate()
17576 if _err != nil {
17577 return _result, _err
17578 }
17579 }
17580 query := map[string]interface{}{}
17581 if !dara.IsNil(request.ClientToken) {
17582 query["ClientToken"] = request.ClientToken
17583 }
17584
17585 if !dara.IsNil(request.ProxyPattern) {
17586 query["ProxyPattern"] = request.ProxyPattern
17587 }
17588
17589 if !dara.IsNil(request.ZoneId) {
17590 query["ZoneId"] = request.ZoneId
17591 }
17592
17593 req := &openapiutil.OpenApiRequest{
17594 Query: openapiutil.Query(query),
17595 }
17596 params := &openapiutil.Params{
17597 Action: dara.String("UpdateRecursionZoneProxyPattern"),
17598 Version: dara.String("2015-01-09"),
17599 Protocol: dara.String("HTTPS"),
17600 Pathname: dara.String("/"),
17601 Method: dara.String("POST"),
17602 AuthType: dara.String("AK"),
17603 Style: dara.String("RPC"),
17604 ReqBodyType: dara.String("formData"),
17605 BodyType: dara.String("json"),
17606 }
17607 _result = &UpdateRecursionZoneProxyPatternResponse{}
17608 _body, _err := client.CallApi(params, req, runtime)
17609 if _err != nil {
17610 return _result, _err
17611 }
17612 _err = dara.Convert(_body, &_result)
17613 return _result, _err
17614 }
17615
17616 // Summary:
17617 //
17618 // 修改递归解析内置权威域名zone递归代理模式
17619 //
17620 // @param request - UpdateRecursionZoneProxyPatternRequest
17621 //
17622 // @return UpdateRecursionZoneProxyPatternResponse
17623 func UpdateRecursionZoneProxyPattern(client *Client, request *UpdateRecursionZoneProxyPatternRequest) (_result *UpdateRecursionZoneProxyPatternResponse, _err error) {
17624 runtime := &dara.RuntimeOptions{}
17625 _result = &UpdateRecursionZoneProxyPatternResponse{}
17626 _body, _err := UpdateRecursionZoneProxyPatternWithOptions(client,request, runtime)
17627 if _err != nil {
17628 return _result, _err
17629 }
17630 _result = _body
17631 return _result, _err
17632 }
17633
17634 // Summary:
17635 //
17636 // 修改递归解析内置权威域名zone备注
17637 //
17638 // @param request - UpdateRecursionZoneRemarkRequest
17639 //
17640 // @param runtime - runtime options for this request RuntimeOptions
17641 //
17642 // @return UpdateRecursionZoneRemarkResponse
17643 func UpdateRecursionZoneRemarkWithOptions(client *Client, request *UpdateRecursionZoneRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneRemarkResponse, _err error) {
17644 if dara.BoolValue(client.EnableValidate) == true {
17645 _err = request.Validate()
17646 if _err != nil {
17647 return _result, _err
17648 }
17649 }
17650 query := map[string]interface{}{}
17651 if !dara.IsNil(request.ClientToken) {
17652 query["ClientToken"] = request.ClientToken
17653 }
17654
17655 if !dara.IsNil(request.Remark) {
17656 query["Remark"] = request.Remark
17657 }
17658
17659 if !dara.IsNil(request.ZoneId) {
17660 query["ZoneId"] = request.ZoneId
17661 }
17662
17663 req := &openapiutil.OpenApiRequest{
17664 Query: openapiutil.Query(query),
17665 }
17666 params := &openapiutil.Params{
17667 Action: dara.String("UpdateRecursionZoneRemark"),
17668 Version: dara.String("2015-01-09"),
17669 Protocol: dara.String("HTTPS"),
17670 Pathname: dara.String("/"),
17671 Method: dara.String("POST"),
17672 AuthType: dara.String("AK"),
17673 Style: dara.String("RPC"),
17674 ReqBodyType: dara.String("formData"),
17675 BodyType: dara.String("json"),
17676 }
17677 _result = &UpdateRecursionZoneRemarkResponse{}
17678 _body, _err := client.CallApi(params, req, runtime)
17679 if _err != nil {
17680 return _result, _err
17681 }
17682 _err = dara.Convert(_body, &_result)
17683 return _result, _err
17684 }
17685
17686 // Summary:
17687 //
17688 // 修改递归解析内置权威域名zone备注
17689 //
17690 // @param request - UpdateRecursionZoneRemarkRequest
17691 //
17692 // @return UpdateRecursionZoneRemarkResponse
17693 func UpdateRecursionZoneRemark(client *Client, request *UpdateRecursionZoneRemarkRequest) (_result *UpdateRecursionZoneRemarkResponse, _err error) {
17694 runtime := &dara.RuntimeOptions{}
17695 _result = &UpdateRecursionZoneRemarkResponse{}
17696 _body, _err := UpdateRecursionZoneRemarkWithOptions(client,request, runtime)
17697 if _err != nil {
17698 return _result, _err
17699 }
17700 _result = _body
17701 return _result, _err
17702 }
17703
17704 // Summary:
17705 //
17706 // 用于更新域名的状态属性
17707 //
17708 // Description:
17709 //
17710 // ## 请求说明
17711 //
17712 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
17713 //
17714 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
17715 //
17716 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
17717 //
17718 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
17719 //
17720 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
17721 //
17722 // @param request - UpdateRspDomainServerHoldStatusOteRequest
17723 //
17724 // @param runtime - runtime options for this request RuntimeOptions
17725 //
17726 // @return UpdateRspDomainServerHoldStatusOteResponse
17727 func UpdateRspDomainServerHoldStatusOteWithOptions(client *Client, request *UpdateRspDomainServerHoldStatusOteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRspDomainServerHoldStatusOteResponse, _err error) {
17728 if dara.BoolValue(client.EnableValidate) == true {
17729 _err = request.Validate()
17730 if _err != nil {
17731 return _result, _err
17732 }
17733 }
17734 query := map[string]interface{}{}
17735 if !dara.IsNil(request.ClientToken) {
17736 query["ClientToken"] = request.ClientToken
17737 }
17738
17739 if !dara.IsNil(request.DomainName) {
17740 query["DomainName"] = request.DomainName
17741 }
17742
17743 if !dara.IsNil(request.OperatorId) {
17744 query["OperatorId"] = request.OperatorId
17745 }
17746
17747 if !dara.IsNil(request.OperatorType) {
17748 query["OperatorType"] = request.OperatorType
17749 }
17750
17751 if !dara.IsNil(request.ServerHoldStatus) {
17752 query["ServerHoldStatus"] = request.ServerHoldStatus
17753 }
17754
17755 if !dara.IsNil(request.StatusMsg) {
17756 query["StatusMsg"] = request.StatusMsg
17757 }
17758
17759 req := &openapiutil.OpenApiRequest{
17760 Query: openapiutil.Query(query),
17761 }
17762 params := &openapiutil.Params{
17763 Action: dara.String("UpdateRspDomainServerHoldStatusOte"),
17764 Version: dara.String("2015-01-09"),
17765 Protocol: dara.String("HTTPS"),
17766 Pathname: dara.String("/"),
17767 Method: dara.String("POST"),
17768 AuthType: dara.String("AK"),
17769 Style: dara.String("RPC"),
17770 ReqBodyType: dara.String("formData"),
17771 BodyType: dara.String("json"),
17772 }
17773 _result = &UpdateRspDomainServerHoldStatusOteResponse{}
17774 _body, _err := client.CallApi(params, req, runtime)
17775 if _err != nil {
17776 return _result, _err
17777 }
17778 _err = dara.Convert(_body, &_result)
17779 return _result, _err
17780 }
17781
17782 // Summary:
17783 //
17784 // 用于更新域名的状态属性
17785 //
17786 // Description:
17787 //
17788 // ## 请求说明
17789 //
17790 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
17791 //
17792 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
17793 //
17794 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
17795 //
17796 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
17797 //
17798 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
17799 //
17800 // @param request - UpdateRspDomainServerHoldStatusOteRequest
17801 //
17802 // @return UpdateRspDomainServerHoldStatusOteResponse
17803 func UpdateRspDomainServerHoldStatusOte(client *Client, request *UpdateRspDomainServerHoldStatusOteRequest) (_result *UpdateRspDomainServerHoldStatusOteResponse, _err error) {
17804 runtime := &dara.RuntimeOptions{}
17805 _result = &UpdateRspDomainServerHoldStatusOteResponse{}
17806 _body, _err := UpdateRspDomainServerHoldStatusOteWithOptions(client,request, runtime)
17807 if _err != nil {
17808 return _result, _err
17809 }
17810 _result = _body
17811 return _result, _err
17812 }
17813
17814 // Summary:
17815 //
17816 // 用于更新域名的状态属性
17817 //
17818 // Description:
17819 //
17820 // ## 请求说明
17821 //
17822 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
17823 //
17824 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
17825 //
17826 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
17827 //
17828 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
17829 //
17830 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
17831 //
17832 // @param request - UpdateRspDomainStatusOteRequest
17833 //
17834 // @param runtime - runtime options for this request RuntimeOptions
17835 //
17836 // @return UpdateRspDomainStatusOteResponse
17837 func UpdateRspDomainStatusOteWithOptions(client *Client, request *UpdateRspDomainStatusOteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRspDomainStatusOteResponse, _err error) {
17838 if dara.BoolValue(client.EnableValidate) == true {
17839 _err = request.Validate()
17840 if _err != nil {
17841 return _result, _err
17842 }
17843 }
17844 query := map[string]interface{}{}
17845 if !dara.IsNil(request.AddStatusList) {
17846 query["AddStatusList"] = request.AddStatusList
17847 }
17848
17849 if !dara.IsNil(request.ClientToken) {
17850 query["ClientToken"] = request.ClientToken
17851 }
17852
17853 if !dara.IsNil(request.DeleteStatusList) {
17854 query["DeleteStatusList"] = request.DeleteStatusList
17855 }
17856
17857 if !dara.IsNil(request.DomainName) {
17858 query["DomainName"] = request.DomainName
17859 }
17860
17861 if !dara.IsNil(request.OperatorId) {
17862 query["OperatorId"] = request.OperatorId
17863 }
17864
17865 if !dara.IsNil(request.OperatorType) {
17866 query["OperatorType"] = request.OperatorType
17867 }
17868
17869 req := &openapiutil.OpenApiRequest{
17870 Query: openapiutil.Query(query),
17871 }
17872 params := &openapiutil.Params{
17873 Action: dara.String("UpdateRspDomainStatusOte"),
17874 Version: dara.String("2015-01-09"),
17875 Protocol: dara.String("HTTPS"),
17876 Pathname: dara.String("/"),
17877 Method: dara.String("POST"),
17878 AuthType: dara.String("AK"),
17879 Style: dara.String("RPC"),
17880 ReqBodyType: dara.String("formData"),
17881 BodyType: dara.String("json"),
17882 }
17883 _result = &UpdateRspDomainStatusOteResponse{}
17884 _body, _err := client.CallApi(params, req, runtime)
17885 if _err != nil {
17886 return _result, _err
17887 }
17888 _err = dara.Convert(_body, &_result)
17889 return _result, _err
17890 }
17891
17892 // Summary:
17893 //
17894 // 用于更新域名的状态属性
17895 //
17896 // Description:
17897 //
17898 // ## 请求说明
17899 //
17900 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
17901 //
17902 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
17903 //
17904 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
17905 //
17906 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
17907 //
17908 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
17909 //
17910 // @param request - UpdateRspDomainStatusOteRequest
17911 //
17912 // @return UpdateRspDomainStatusOteResponse
17913 func UpdateRspDomainStatusOte(client *Client, request *UpdateRspDomainStatusOteRequest) (_result *UpdateRspDomainStatusOteResponse, _err error) {
17914 runtime := &dara.RuntimeOptions{}
17915 _result = &UpdateRspDomainStatusOteResponse{}
17916 _body, _err := UpdateRspDomainStatusOteWithOptions(client,request, runtime)
17917 if _err != nil {
17918 return _result, _err
17919 }
17920 _result = _body
17921 return _result, _err
17922 }
17923
17924 // Summary:
17925 //
17926 // 检查实例主机名是否可添加
17927 //
17928 // @param request - ValidateDnsGtmCnameRrCanUseRequest
17929 //
17930 // @param runtime - runtime options for this request RuntimeOptions
17931 //
17932 // @return ValidateDnsGtmCnameRrCanUseResponse
17933 func ValidateDnsGtmCnameRrCanUseWithOptions(client *Client, request *ValidateDnsGtmCnameRrCanUseRequest, runtime *dara.RuntimeOptions) (_result *ValidateDnsGtmCnameRrCanUseResponse, _err error) {
17934 if dara.BoolValue(client.EnableValidate) == true {
17935 _err = request.Validate()
17936 if _err != nil {
17937 return _result, _err
17938 }
17939 }
17940 query := map[string]interface{}{}
17941 if !dara.IsNil(request.CnameMode) {
17942 query["CnameMode"] = request.CnameMode
17943 }
17944
17945 if !dara.IsNil(request.CnameRr) {
17946 query["CnameRr"] = request.CnameRr
17947 }
17948
17949 if !dara.IsNil(request.CnameType) {
17950 query["CnameType"] = request.CnameType
17951 }
17952
17953 if !dara.IsNil(request.CnameZone) {
17954 query["CnameZone"] = request.CnameZone
17955 }
17956
17957 if !dara.IsNil(request.InstanceId) {
17958 query["InstanceId"] = request.InstanceId
17959 }
17960
17961 if !dara.IsNil(request.Lang) {
17962 query["Lang"] = request.Lang
17963 }
17964
17965 req := &openapiutil.OpenApiRequest{
17966 Query: openapiutil.Query(query),
17967 }
17968 params := &openapiutil.Params{
17969 Action: dara.String("ValidateDnsGtmCnameRrCanUse"),
17970 Version: dara.String("2015-01-09"),
17971 Protocol: dara.String("HTTPS"),
17972 Pathname: dara.String("/"),
17973 Method: dara.String("POST"),
17974 AuthType: dara.String("AK"),
17975 Style: dara.String("RPC"),
17976 ReqBodyType: dara.String("formData"),
17977 BodyType: dara.String("json"),
17978 }
17979 _result = &ValidateDnsGtmCnameRrCanUseResponse{}
17980 _body, _err := client.CallApi(params, req, runtime)
17981 if _err != nil {
17982 return _result, _err
17983 }
17984 _err = dara.Convert(_body, &_result)
17985 return _result, _err
17986 }
17987
17988 // Summary:
17989 //
17990 // 检查实例主机名是否可添加
17991 //
17992 // @param request - ValidateDnsGtmCnameRrCanUseRequest
17993 //
17994 // @return ValidateDnsGtmCnameRrCanUseResponse
17995 func ValidateDnsGtmCnameRrCanUse(client *Client, request *ValidateDnsGtmCnameRrCanUseRequest) (_result *ValidateDnsGtmCnameRrCanUseResponse, _err error) {
17996 runtime := &dara.RuntimeOptions{}
17997 _result = &ValidateDnsGtmCnameRrCanUseResponse{}
17998 _body, _err := ValidateDnsGtmCnameRrCanUseWithOptions(client,request, runtime)
17999 if _err != nil {
18000 return _result, _err
18001 }
18002 _result = _body
18003 return _result, _err
18004 }
18005
18006 // Summary:
18007 //
18008 // 验证公共DNS Udp Ip地址段
18009 //
18010 // @param request - ValidatePdnsUdpIpSegmentRequest
18011 //
18012 // @param runtime - runtime options for this request RuntimeOptions
18013 //
18014 // @return ValidatePdnsUdpIpSegmentResponse
18015 func ValidatePdnsUdpIpSegmentWithOptions(client *Client, request *ValidatePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *ValidatePdnsUdpIpSegmentResponse, _err error) {
18016 if dara.BoolValue(client.EnableValidate) == true {
18017 _err = request.Validate()
18018 if _err != nil {
18019 return _result, _err
18020 }
18021 }
18022 query := map[string]interface{}{}
18023 if !dara.IsNil(request.Ip) {
18024 query["Ip"] = request.Ip
18025 }
18026
18027 if !dara.IsNil(request.IpToken) {
18028 query["IpToken"] = request.IpToken
18029 }
18030
18031 if !dara.IsNil(request.Lang) {
18032 query["Lang"] = request.Lang
18033 }
18034
18035 req := &openapiutil.OpenApiRequest{
18036 Query: openapiutil.Query(query),
18037 }
18038 params := &openapiutil.Params{
18039 Action: dara.String("ValidatePdnsUdpIpSegment"),
18040 Version: dara.String("2015-01-09"),
18041 Protocol: dara.String("HTTPS"),
18042 Pathname: dara.String("/"),
18043 Method: dara.String("POST"),
18044 AuthType: dara.String("AK"),
18045 Style: dara.String("RPC"),
18046 ReqBodyType: dara.String("formData"),
18047 BodyType: dara.String("json"),
18048 }
18049 _result = &ValidatePdnsUdpIpSegmentResponse{}
18050 _body, _err := client.CallApi(params, req, runtime)
18051 if _err != nil {
18052 return _result, _err
18053 }
18054 _err = dara.Convert(_body, &_result)
18055 return _result, _err
18056 }
18057
18058 // Summary:
18059 //
18060 // 验证公共DNS Udp Ip地址段
18061 //
18062 // @param request - ValidatePdnsUdpIpSegmentRequest
18063 //
18064 // @return ValidatePdnsUdpIpSegmentResponse
18065 func ValidatePdnsUdpIpSegment(client *Client, request *ValidatePdnsUdpIpSegmentRequest) (_result *ValidatePdnsUdpIpSegmentResponse, _err error) {
18066 runtime := &dara.RuntimeOptions{}
18067 _result = &ValidatePdnsUdpIpSegmentResponse{}
18068 _body, _err := ValidatePdnsUdpIpSegmentWithOptions(client,request, runtime)
18069 if _err != nil {
18070 return _result, _err
18071 }
18072 _result = _body
18073 return _result, _err
18074 }
18075