modifiedclient_context_func.go raw
1 // This file is auto-generated, don't edit it. Thanks.
2 package client
3
4 import (
5 "context"
6 openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
7 "github.com/alibabacloud-go/tea/dara"
8 )
9
10 // Summary:
11 //
12 // Adds a custom line to the domain name.
13 //
14 // Description:
15 //
16 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
17 //
18 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
19 //
20 // @param request - AddCustomLineRequest
21 //
22 // @param runtime - runtime options for this request RuntimeOptions
23 //
24 // @return AddCustomLineResponse
25 func AddCustomLineWithContext(ctx context.Context, client *Client, request *AddCustomLineRequest, runtime *dara.RuntimeOptions) (_result *AddCustomLineResponse, _err error) {
26 if dara.BoolValue(client.EnableValidate) == true {
27 _err = request.Validate()
28 if _err != nil {
29 return _result, _err
30 }
31 }
32 query := map[string]interface{}{}
33 if !dara.IsNil(request.DomainName) {
34 query["DomainName"] = request.DomainName
35 }
36
37 if !dara.IsNil(request.IpSegment) {
38 query["IpSegment"] = request.IpSegment
39 }
40
41 if !dara.IsNil(request.Lang) {
42 query["Lang"] = request.Lang
43 }
44
45 if !dara.IsNil(request.LineName) {
46 query["LineName"] = request.LineName
47 }
48
49 req := &openapiutil.OpenApiRequest{
50 Query: openapiutil.Query(query),
51 }
52 params := &openapiutil.Params{
53 Action: dara.String("AddCustomLine"),
54 Version: dara.String("2015-01-09"),
55 Protocol: dara.String("HTTPS"),
56 Pathname: dara.String("/"),
57 Method: dara.String("POST"),
58 AuthType: dara.String("AK"),
59 Style: dara.String("RPC"),
60 ReqBodyType: dara.String("formData"),
61 BodyType: dara.String("json"),
62 }
63 _result = &AddCustomLineResponse{}
64 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
65 if _err != nil {
66 return _result, _err
67 }
68 _err = dara.Convert(_body, &_result)
69 return _result, _err
70 }
71
72 // Summary:
73 //
74 // Adds a cache-accelerated domain name based on the specified parameters.
75 //
76 // @param request - AddDnsCacheDomainRequest
77 //
78 // @param runtime - runtime options for this request RuntimeOptions
79 //
80 // @return AddDnsCacheDomainResponse
81 func AddDnsCacheDomainWithContext(ctx context.Context, client *Client, request *AddDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *AddDnsCacheDomainResponse, _err error) {
82 if dara.BoolValue(client.EnableValidate) == true {
83 _err = request.Validate()
84 if _err != nil {
85 return _result, _err
86 }
87 }
88 query := map[string]interface{}{}
89 if !dara.IsNil(request.CacheTtlMax) {
90 query["CacheTtlMax"] = request.CacheTtlMax
91 }
92
93 if !dara.IsNil(request.CacheTtlMin) {
94 query["CacheTtlMin"] = request.CacheTtlMin
95 }
96
97 if !dara.IsNil(request.DomainName) {
98 query["DomainName"] = request.DomainName
99 }
100
101 if !dara.IsNil(request.InstanceId) {
102 query["InstanceId"] = request.InstanceId
103 }
104
105 if !dara.IsNil(request.Lang) {
106 query["Lang"] = request.Lang
107 }
108
109 if !dara.IsNil(request.Remark) {
110 query["Remark"] = request.Remark
111 }
112
113 if !dara.IsNil(request.SourceDnsServer) {
114 query["SourceDnsServer"] = request.SourceDnsServer
115 }
116
117 if !dara.IsNil(request.SourceEdns) {
118 query["SourceEdns"] = request.SourceEdns
119 }
120
121 if !dara.IsNil(request.SourceProtocol) {
122 query["SourceProtocol"] = request.SourceProtocol
123 }
124
125 req := &openapiutil.OpenApiRequest{
126 Query: openapiutil.Query(query),
127 }
128 params := &openapiutil.Params{
129 Action: dara.String("AddDnsCacheDomain"),
130 Version: dara.String("2015-01-09"),
131 Protocol: dara.String("HTTPS"),
132 Pathname: dara.String("/"),
133 Method: dara.String("POST"),
134 AuthType: dara.String("AK"),
135 Style: dara.String("RPC"),
136 ReqBodyType: dara.String("formData"),
137 BodyType: dara.String("json"),
138 }
139 _result = &AddDnsCacheDomainResponse{}
140 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
141 if _err != nil {
142 return _result, _err
143 }
144 _err = dara.Convert(_body, &_result)
145 return _result, _err
146 }
147
148 // Summary:
149 //
150 // Creates an access policy.
151 //
152 // @param request - AddDnsGtmAccessStrategyRequest
153 //
154 // @param runtime - runtime options for this request RuntimeOptions
155 //
156 // @return AddDnsGtmAccessStrategyResponse
157 func AddDnsGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *AddDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmAccessStrategyResponse, _err error) {
158 if dara.BoolValue(client.EnableValidate) == true {
159 _err = request.Validate()
160 if _err != nil {
161 return _result, _err
162 }
163 }
164 query := map[string]interface{}{}
165 if !dara.IsNil(request.DefaultAddrPool) {
166 query["DefaultAddrPool"] = request.DefaultAddrPool
167 }
168
169 if !dara.IsNil(request.DefaultAddrPoolType) {
170 query["DefaultAddrPoolType"] = request.DefaultAddrPoolType
171 }
172
173 if !dara.IsNil(request.DefaultLatencyOptimization) {
174 query["DefaultLatencyOptimization"] = request.DefaultLatencyOptimization
175 }
176
177 if !dara.IsNil(request.DefaultLbaStrategy) {
178 query["DefaultLbaStrategy"] = request.DefaultLbaStrategy
179 }
180
181 if !dara.IsNil(request.DefaultMaxReturnAddrNum) {
182 query["DefaultMaxReturnAddrNum"] = request.DefaultMaxReturnAddrNum
183 }
184
185 if !dara.IsNil(request.DefaultMinAvailableAddrNum) {
186 query["DefaultMinAvailableAddrNum"] = request.DefaultMinAvailableAddrNum
187 }
188
189 if !dara.IsNil(request.FailoverAddrPool) {
190 query["FailoverAddrPool"] = request.FailoverAddrPool
191 }
192
193 if !dara.IsNil(request.FailoverAddrPoolType) {
194 query["FailoverAddrPoolType"] = request.FailoverAddrPoolType
195 }
196
197 if !dara.IsNil(request.FailoverLatencyOptimization) {
198 query["FailoverLatencyOptimization"] = request.FailoverLatencyOptimization
199 }
200
201 if !dara.IsNil(request.FailoverLbaStrategy) {
202 query["FailoverLbaStrategy"] = request.FailoverLbaStrategy
203 }
204
205 if !dara.IsNil(request.FailoverMaxReturnAddrNum) {
206 query["FailoverMaxReturnAddrNum"] = request.FailoverMaxReturnAddrNum
207 }
208
209 if !dara.IsNil(request.FailoverMinAvailableAddrNum) {
210 query["FailoverMinAvailableAddrNum"] = request.FailoverMinAvailableAddrNum
211 }
212
213 if !dara.IsNil(request.InstanceId) {
214 query["InstanceId"] = request.InstanceId
215 }
216
217 if !dara.IsNil(request.Lang) {
218 query["Lang"] = request.Lang
219 }
220
221 if !dara.IsNil(request.Lines) {
222 query["Lines"] = request.Lines
223 }
224
225 if !dara.IsNil(request.StrategyMode) {
226 query["StrategyMode"] = request.StrategyMode
227 }
228
229 if !dara.IsNil(request.StrategyName) {
230 query["StrategyName"] = request.StrategyName
231 }
232
233 req := &openapiutil.OpenApiRequest{
234 Query: openapiutil.Query(query),
235 }
236 params := &openapiutil.Params{
237 Action: dara.String("AddDnsGtmAccessStrategy"),
238 Version: dara.String("2015-01-09"),
239 Protocol: dara.String("HTTPS"),
240 Pathname: dara.String("/"),
241 Method: dara.String("POST"),
242 AuthType: dara.String("AK"),
243 Style: dara.String("RPC"),
244 ReqBodyType: dara.String("formData"),
245 BodyType: dara.String("json"),
246 }
247 _result = &AddDnsGtmAccessStrategyResponse{}
248 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
249 if _err != nil {
250 return _result, _err
251 }
252 _err = dara.Convert(_body, &_result)
253 return _result, _err
254 }
255
256 // Summary:
257 //
258 // Creates an address pool.
259 //
260 // @param request - AddDnsGtmAddressPoolRequest
261 //
262 // @param runtime - runtime options for this request RuntimeOptions
263 //
264 // @return AddDnsGtmAddressPoolResponse
265 func AddDnsGtmAddressPoolWithContext(ctx context.Context, client *Client, request *AddDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmAddressPoolResponse, _err error) {
266 if dara.BoolValue(client.EnableValidate) == true {
267 _err = request.Validate()
268 if _err != nil {
269 return _result, _err
270 }
271 }
272 query := map[string]interface{}{}
273 if !dara.IsNil(request.Addr) {
274 query["Addr"] = request.Addr
275 }
276
277 if !dara.IsNil(request.EvaluationCount) {
278 query["EvaluationCount"] = request.EvaluationCount
279 }
280
281 if !dara.IsNil(request.InstanceId) {
282 query["InstanceId"] = request.InstanceId
283 }
284
285 if !dara.IsNil(request.Interval) {
286 query["Interval"] = request.Interval
287 }
288
289 if !dara.IsNil(request.IspCityNode) {
290 query["IspCityNode"] = request.IspCityNode
291 }
292
293 if !dara.IsNil(request.Lang) {
294 query["Lang"] = request.Lang
295 }
296
297 if !dara.IsNil(request.LbaStrategy) {
298 query["LbaStrategy"] = request.LbaStrategy
299 }
300
301 if !dara.IsNil(request.MonitorExtendInfo) {
302 query["MonitorExtendInfo"] = request.MonitorExtendInfo
303 }
304
305 if !dara.IsNil(request.MonitorStatus) {
306 query["MonitorStatus"] = request.MonitorStatus
307 }
308
309 if !dara.IsNil(request.Name) {
310 query["Name"] = request.Name
311 }
312
313 if !dara.IsNil(request.ProtocolType) {
314 query["ProtocolType"] = request.ProtocolType
315 }
316
317 if !dara.IsNil(request.Timeout) {
318 query["Timeout"] = request.Timeout
319 }
320
321 if !dara.IsNil(request.Type) {
322 query["Type"] = request.Type
323 }
324
325 req := &openapiutil.OpenApiRequest{
326 Query: openapiutil.Query(query),
327 }
328 params := &openapiutil.Params{
329 Action: dara.String("AddDnsGtmAddressPool"),
330 Version: dara.String("2015-01-09"),
331 Protocol: dara.String("HTTPS"),
332 Pathname: dara.String("/"),
333 Method: dara.String("POST"),
334 AuthType: dara.String("AK"),
335 Style: dara.String("RPC"),
336 ReqBodyType: dara.String("formData"),
337 BodyType: dara.String("json"),
338 }
339 _result = &AddDnsGtmAddressPoolResponse{}
340 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
341 if _err != nil {
342 return _result, _err
343 }
344 _err = dara.Convert(_body, &_result)
345 return _result, _err
346 }
347
348 // Summary:
349 //
350 // Creates a health check task.
351 //
352 // Description:
353 //
354 // **
355 //
356 // @param request - AddDnsGtmMonitorRequest
357 //
358 // @param runtime - runtime options for this request RuntimeOptions
359 //
360 // @return AddDnsGtmMonitorResponse
361 func AddDnsGtmMonitorWithContext(ctx context.Context, client *Client, request *AddDnsGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *AddDnsGtmMonitorResponse, _err error) {
362 if dara.BoolValue(client.EnableValidate) == true {
363 _err = request.Validate()
364 if _err != nil {
365 return _result, _err
366 }
367 }
368 query := map[string]interface{}{}
369 if !dara.IsNil(request.AddrPoolId) {
370 query["AddrPoolId"] = request.AddrPoolId
371 }
372
373 if !dara.IsNil(request.EvaluationCount) {
374 query["EvaluationCount"] = request.EvaluationCount
375 }
376
377 if !dara.IsNil(request.Interval) {
378 query["Interval"] = request.Interval
379 }
380
381 if !dara.IsNil(request.IspCityNode) {
382 query["IspCityNode"] = request.IspCityNode
383 }
384
385 if !dara.IsNil(request.Lang) {
386 query["Lang"] = request.Lang
387 }
388
389 if !dara.IsNil(request.MonitorExtendInfo) {
390 query["MonitorExtendInfo"] = request.MonitorExtendInfo
391 }
392
393 if !dara.IsNil(request.ProtocolType) {
394 query["ProtocolType"] = request.ProtocolType
395 }
396
397 if !dara.IsNil(request.Timeout) {
398 query["Timeout"] = request.Timeout
399 }
400
401 req := &openapiutil.OpenApiRequest{
402 Query: openapiutil.Query(query),
403 }
404 params := &openapiutil.Params{
405 Action: dara.String("AddDnsGtmMonitor"),
406 Version: dara.String("2015-01-09"),
407 Protocol: dara.String("HTTPS"),
408 Pathname: dara.String("/"),
409 Method: dara.String("POST"),
410 AuthType: dara.String("AK"),
411 Style: dara.String("RPC"),
412 ReqBodyType: dara.String("formData"),
413 BodyType: dara.String("json"),
414 }
415 _result = &AddDnsGtmMonitorResponse{}
416 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
417 if _err != nil {
418 return _result, _err
419 }
420 _err = dara.Convert(_body, &_result)
421 return _result, _err
422 }
423
424 // Summary:
425 //
426 // Adds a domain name based on the specified parameters.
427 //
428 // Description:
429 //
430 // # For more information about how to check whether a domain name is valid, see
431 //
432 // [Domain name validity](https://www.alibabacloud.com/help/zh/doc-detail/67788.htm).
433 //
434 // @param request - AddDomainRequest
435 //
436 // @param runtime - runtime options for this request RuntimeOptions
437 //
438 // @return AddDomainResponse
439 func AddDomainWithContext(ctx context.Context, client *Client, request *AddDomainRequest, runtime *dara.RuntimeOptions) (_result *AddDomainResponse, _err error) {
440 if dara.BoolValue(client.EnableValidate) == true {
441 _err = request.Validate()
442 if _err != nil {
443 return _result, _err
444 }
445 }
446 query := map[string]interface{}{}
447 if !dara.IsNil(request.DomainName) {
448 query["DomainName"] = request.DomainName
449 }
450
451 if !dara.IsNil(request.GroupId) {
452 query["GroupId"] = request.GroupId
453 }
454
455 if !dara.IsNil(request.Lang) {
456 query["Lang"] = request.Lang
457 }
458
459 if !dara.IsNil(request.ResourceGroupId) {
460 query["ResourceGroupId"] = request.ResourceGroupId
461 }
462
463 req := &openapiutil.OpenApiRequest{
464 Query: openapiutil.Query(query),
465 }
466 params := &openapiutil.Params{
467 Action: dara.String("AddDomain"),
468 Version: dara.String("2015-01-09"),
469 Protocol: dara.String("HTTPS"),
470 Pathname: dara.String("/"),
471 Method: dara.String("POST"),
472 AuthType: dara.String("AK"),
473 Style: dara.String("RPC"),
474 ReqBodyType: dara.String("formData"),
475 BodyType: dara.String("json"),
476 }
477 _result = &AddDomainResponse{}
478 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
479 if _err != nil {
480 return _result, _err
481 }
482 _err = dara.Convert(_body, &_result)
483 return _result, _err
484 }
485
486 // Summary:
487 //
488 // Creates a backup task for a domain name.
489 //
490 // @param request - AddDomainBackupRequest
491 //
492 // @param runtime - runtime options for this request RuntimeOptions
493 //
494 // @return AddDomainBackupResponse
495 func AddDomainBackupWithContext(ctx context.Context, client *Client, request *AddDomainBackupRequest, runtime *dara.RuntimeOptions) (_result *AddDomainBackupResponse, _err error) {
496 if dara.BoolValue(client.EnableValidate) == true {
497 _err = request.Validate()
498 if _err != nil {
499 return _result, _err
500 }
501 }
502 query := map[string]interface{}{}
503 if !dara.IsNil(request.DomainName) {
504 query["DomainName"] = request.DomainName
505 }
506
507 if !dara.IsNil(request.Lang) {
508 query["Lang"] = request.Lang
509 }
510
511 if !dara.IsNil(request.PeriodType) {
512 query["PeriodType"] = request.PeriodType
513 }
514
515 req := &openapiutil.OpenApiRequest{
516 Query: openapiutil.Query(query),
517 }
518 params := &openapiutil.Params{
519 Action: dara.String("AddDomainBackup"),
520 Version: dara.String("2015-01-09"),
521 Protocol: dara.String("HTTPS"),
522 Pathname: dara.String("/"),
523 Method: dara.String("POST"),
524 AuthType: dara.String("AK"),
525 Style: dara.String("RPC"),
526 ReqBodyType: dara.String("formData"),
527 BodyType: dara.String("json"),
528 }
529 _result = &AddDomainBackupResponse{}
530 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
531 if _err != nil {
532 return _result, _err
533 }
534 _err = dara.Convert(_body, &_result)
535 return _result, _err
536 }
537
538 // Summary:
539 //
540 // Creates a domain name group based on the specified parameters.
541 //
542 // @param request - AddDomainGroupRequest
543 //
544 // @param runtime - runtime options for this request RuntimeOptions
545 //
546 // @return AddDomainGroupResponse
547 func AddDomainGroupWithContext(ctx context.Context, client *Client, request *AddDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *AddDomainGroupResponse, _err error) {
548 if dara.BoolValue(client.EnableValidate) == true {
549 _err = request.Validate()
550 if _err != nil {
551 return _result, _err
552 }
553 }
554 query := map[string]interface{}{}
555 if !dara.IsNil(request.GroupName) {
556 query["GroupName"] = request.GroupName
557 }
558
559 if !dara.IsNil(request.Lang) {
560 query["Lang"] = request.Lang
561 }
562
563 req := &openapiutil.OpenApiRequest{
564 Query: openapiutil.Query(query),
565 }
566 params := &openapiutil.Params{
567 Action: dara.String("AddDomainGroup"),
568 Version: dara.String("2015-01-09"),
569 Protocol: dara.String("HTTPS"),
570 Pathname: dara.String("/"),
571 Method: dara.String("POST"),
572 AuthType: dara.String("AK"),
573 Style: dara.String("RPC"),
574 ReqBodyType: dara.String("formData"),
575 BodyType: dara.String("json"),
576 }
577 _result = &AddDomainGroupResponse{}
578 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
579 if _err != nil {
580 return _result, _err
581 }
582 _err = dara.Convert(_body, &_result)
583 return _result, _err
584 }
585
586 // Summary:
587 //
588 // Adds a Domain Name System (DNS) record based on the specified parameters.
589 //
590 // @param request - AddDomainRecordRequest
591 //
592 // @param runtime - runtime options for this request RuntimeOptions
593 //
594 // @return AddDomainRecordResponse
595 func AddDomainRecordWithContext(ctx context.Context, client *Client, request *AddDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *AddDomainRecordResponse, _err error) {
596 if dara.BoolValue(client.EnableValidate) == true {
597 _err = request.Validate()
598 if _err != nil {
599 return _result, _err
600 }
601 }
602 query := map[string]interface{}{}
603 if !dara.IsNil(request.DomainName) {
604 query["DomainName"] = request.DomainName
605 }
606
607 if !dara.IsNil(request.Lang) {
608 query["Lang"] = request.Lang
609 }
610
611 if !dara.IsNil(request.Line) {
612 query["Line"] = request.Line
613 }
614
615 if !dara.IsNil(request.Priority) {
616 query["Priority"] = request.Priority
617 }
618
619 if !dara.IsNil(request.RR) {
620 query["RR"] = request.RR
621 }
622
623 if !dara.IsNil(request.TTL) {
624 query["TTL"] = request.TTL
625 }
626
627 if !dara.IsNil(request.Type) {
628 query["Type"] = request.Type
629 }
630
631 if !dara.IsNil(request.UserClientIp) {
632 query["UserClientIp"] = request.UserClientIp
633 }
634
635 if !dara.IsNil(request.Value) {
636 query["Value"] = request.Value
637 }
638
639 req := &openapiutil.OpenApiRequest{
640 Query: openapiutil.Query(query),
641 }
642 params := &openapiutil.Params{
643 Action: dara.String("AddDomainRecord"),
644 Version: dara.String("2015-01-09"),
645 Protocol: dara.String("HTTPS"),
646 Pathname: dara.String("/"),
647 Method: dara.String("POST"),
648 AuthType: dara.String("AK"),
649 Style: dara.String("RPC"),
650 ReqBodyType: dara.String("formData"),
651 BodyType: dara.String("json"),
652 }
653 _result = &AddDomainRecordResponse{}
654 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
655 if _err != nil {
656 return _result, _err
657 }
658 _err = dara.Convert(_body, &_result)
659 return _result, _err
660 }
661
662 // @param request - AddGtmAccessStrategyRequest
663 //
664 // @param runtime - runtime options for this request RuntimeOptions
665 //
666 // @return AddGtmAccessStrategyResponse
667 func AddGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *AddGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *AddGtmAccessStrategyResponse, _err error) {
668 if dara.BoolValue(client.EnableValidate) == true {
669 _err = request.Validate()
670 if _err != nil {
671 return _result, _err
672 }
673 }
674 query := map[string]interface{}{}
675 if !dara.IsNil(request.AccessLines) {
676 query["AccessLines"] = request.AccessLines
677 }
678
679 if !dara.IsNil(request.DefaultAddrPoolId) {
680 query["DefaultAddrPoolId"] = request.DefaultAddrPoolId
681 }
682
683 if !dara.IsNil(request.FailoverAddrPoolId) {
684 query["FailoverAddrPoolId"] = request.FailoverAddrPoolId
685 }
686
687 if !dara.IsNil(request.InstanceId) {
688 query["InstanceId"] = request.InstanceId
689 }
690
691 if !dara.IsNil(request.Lang) {
692 query["Lang"] = request.Lang
693 }
694
695 if !dara.IsNil(request.StrategyName) {
696 query["StrategyName"] = request.StrategyName
697 }
698
699 req := &openapiutil.OpenApiRequest{
700 Query: openapiutil.Query(query),
701 }
702 params := &openapiutil.Params{
703 Action: dara.String("AddGtmAccessStrategy"),
704 Version: dara.String("2015-01-09"),
705 Protocol: dara.String("HTTPS"),
706 Pathname: dara.String("/"),
707 Method: dara.String("POST"),
708 AuthType: dara.String("AK"),
709 Style: dara.String("RPC"),
710 ReqBodyType: dara.String("formData"),
711 BodyType: dara.String("json"),
712 }
713 _result = &AddGtmAccessStrategyResponse{}
714 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
715 if _err != nil {
716 return _result, _err
717 }
718 _err = dara.Convert(_body, &_result)
719 return _result, _err
720 }
721
722 // Summary:
723 //
724 // Creates an address pool.
725 //
726 // @param request - AddGtmAddressPoolRequest
727 //
728 // @param runtime - runtime options for this request RuntimeOptions
729 //
730 // @return AddGtmAddressPoolResponse
731 func AddGtmAddressPoolWithContext(ctx context.Context, client *Client, request *AddGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *AddGtmAddressPoolResponse, _err error) {
732 if dara.BoolValue(client.EnableValidate) == true {
733 _err = request.Validate()
734 if _err != nil {
735 return _result, _err
736 }
737 }
738 query := map[string]interface{}{}
739 if !dara.IsNil(request.Addr) {
740 query["Addr"] = request.Addr
741 }
742
743 if !dara.IsNil(request.EvaluationCount) {
744 query["EvaluationCount"] = request.EvaluationCount
745 }
746
747 if !dara.IsNil(request.InstanceId) {
748 query["InstanceId"] = request.InstanceId
749 }
750
751 if !dara.IsNil(request.Interval) {
752 query["Interval"] = request.Interval
753 }
754
755 if !dara.IsNil(request.IspCityNode) {
756 query["IspCityNode"] = request.IspCityNode
757 }
758
759 if !dara.IsNil(request.Lang) {
760 query["Lang"] = request.Lang
761 }
762
763 if !dara.IsNil(request.MinAvailableAddrNum) {
764 query["MinAvailableAddrNum"] = request.MinAvailableAddrNum
765 }
766
767 if !dara.IsNil(request.MonitorExtendInfo) {
768 query["MonitorExtendInfo"] = request.MonitorExtendInfo
769 }
770
771 if !dara.IsNil(request.MonitorStatus) {
772 query["MonitorStatus"] = request.MonitorStatus
773 }
774
775 if !dara.IsNil(request.Name) {
776 query["Name"] = request.Name
777 }
778
779 if !dara.IsNil(request.ProtocolType) {
780 query["ProtocolType"] = request.ProtocolType
781 }
782
783 if !dara.IsNil(request.Timeout) {
784 query["Timeout"] = request.Timeout
785 }
786
787 if !dara.IsNil(request.Type) {
788 query["Type"] = request.Type
789 }
790
791 req := &openapiutil.OpenApiRequest{
792 Query: openapiutil.Query(query),
793 }
794 params := &openapiutil.Params{
795 Action: dara.String("AddGtmAddressPool"),
796 Version: dara.String("2015-01-09"),
797 Protocol: dara.String("HTTPS"),
798 Pathname: dara.String("/"),
799 Method: dara.String("POST"),
800 AuthType: dara.String("AK"),
801 Style: dara.String("RPC"),
802 ReqBodyType: dara.String("formData"),
803 BodyType: dara.String("json"),
804 }
805 _result = &AddGtmAddressPoolResponse{}
806 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
807 if _err != nil {
808 return _result, _err
809 }
810 _err = dara.Convert(_body, &_result)
811 return _result, _err
812 }
813
814 // Summary:
815 //
816 // Creates a health check task.
817 //
818 // @param request - AddGtmMonitorRequest
819 //
820 // @param runtime - runtime options for this request RuntimeOptions
821 //
822 // @return AddGtmMonitorResponse
823 func AddGtmMonitorWithContext(ctx context.Context, client *Client, request *AddGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *AddGtmMonitorResponse, _err error) {
824 if dara.BoolValue(client.EnableValidate) == true {
825 _err = request.Validate()
826 if _err != nil {
827 return _result, _err
828 }
829 }
830 query := map[string]interface{}{}
831 if !dara.IsNil(request.AddrPoolId) {
832 query["AddrPoolId"] = request.AddrPoolId
833 }
834
835 if !dara.IsNil(request.EvaluationCount) {
836 query["EvaluationCount"] = request.EvaluationCount
837 }
838
839 if !dara.IsNil(request.Interval) {
840 query["Interval"] = request.Interval
841 }
842
843 if !dara.IsNil(request.IspCityNode) {
844 query["IspCityNode"] = request.IspCityNode
845 }
846
847 if !dara.IsNil(request.Lang) {
848 query["Lang"] = request.Lang
849 }
850
851 if !dara.IsNil(request.MonitorExtendInfo) {
852 query["MonitorExtendInfo"] = request.MonitorExtendInfo
853 }
854
855 if !dara.IsNil(request.ProtocolType) {
856 query["ProtocolType"] = request.ProtocolType
857 }
858
859 if !dara.IsNil(request.Timeout) {
860 query["Timeout"] = request.Timeout
861 }
862
863 req := &openapiutil.OpenApiRequest{
864 Query: openapiutil.Query(query),
865 }
866 params := &openapiutil.Params{
867 Action: dara.String("AddGtmMonitor"),
868 Version: dara.String("2015-01-09"),
869 Protocol: dara.String("HTTPS"),
870 Pathname: dara.String("/"),
871 Method: dara.String("POST"),
872 AuthType: dara.String("AK"),
873 Style: dara.String("RPC"),
874 ReqBodyType: dara.String("formData"),
875 BodyType: dara.String("json"),
876 }
877 _result = &AddGtmMonitorResponse{}
878 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
879 if _err != nil {
880 return _result, _err
881 }
882 _err = dara.Convert(_body, &_result)
883 return _result, _err
884 }
885
886 // Summary:
887 //
888 // Creates a disaster recovery plan.
889 //
890 // @param request - AddGtmRecoveryPlanRequest
891 //
892 // @param runtime - runtime options for this request RuntimeOptions
893 //
894 // @return AddGtmRecoveryPlanResponse
895 func AddGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *AddGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *AddGtmRecoveryPlanResponse, _err error) {
896 if dara.BoolValue(client.EnableValidate) == true {
897 _err = request.Validate()
898 if _err != nil {
899 return _result, _err
900 }
901 }
902 query := map[string]interface{}{}
903 if !dara.IsNil(request.FaultAddrPool) {
904 query["FaultAddrPool"] = request.FaultAddrPool
905 }
906
907 if !dara.IsNil(request.Lang) {
908 query["Lang"] = request.Lang
909 }
910
911 if !dara.IsNil(request.Name) {
912 query["Name"] = request.Name
913 }
914
915 if !dara.IsNil(request.Remark) {
916 query["Remark"] = request.Remark
917 }
918
919 req := &openapiutil.OpenApiRequest{
920 Query: openapiutil.Query(query),
921 }
922 params := &openapiutil.Params{
923 Action: dara.String("AddGtmRecoveryPlan"),
924 Version: dara.String("2015-01-09"),
925 Protocol: dara.String("HTTPS"),
926 Pathname: dara.String("/"),
927 Method: dara.String("POST"),
928 AuthType: dara.String("AK"),
929 Style: dara.String("RPC"),
930 ReqBodyType: dara.String("formData"),
931 BodyType: dara.String("json"),
932 }
933 _result = &AddGtmRecoveryPlanResponse{}
934 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
935 if _err != nil {
936 return _result, _err
937 }
938 _err = dara.Convert(_body, &_result)
939 return _result, _err
940 }
941
942 // Summary:
943 //
944 // 新增递归解析内置权威解析记录
945 //
946 // @param request - AddRecursionRecordRequest
947 //
948 // @param runtime - runtime options for this request RuntimeOptions
949 //
950 // @return AddRecursionRecordResponse
951 func AddRecursionRecordWithContext(ctx context.Context, client *Client, request *AddRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *AddRecursionRecordResponse, _err error) {
952 if dara.BoolValue(client.EnableValidate) == true {
953 _err = request.Validate()
954 if _err != nil {
955 return _result, _err
956 }
957 }
958 query := map[string]interface{}{}
959 if !dara.IsNil(request.ClientToken) {
960 query["ClientToken"] = request.ClientToken
961 }
962
963 if !dara.IsNil(request.Priority) {
964 query["Priority"] = request.Priority
965 }
966
967 if !dara.IsNil(request.RequestSource) {
968 query["RequestSource"] = request.RequestSource
969 }
970
971 if !dara.IsNil(request.Rr) {
972 query["Rr"] = request.Rr
973 }
974
975 if !dara.IsNil(request.Ttl) {
976 query["Ttl"] = request.Ttl
977 }
978
979 if !dara.IsNil(request.Type) {
980 query["Type"] = request.Type
981 }
982
983 if !dara.IsNil(request.UserClientIp) {
984 query["UserClientIp"] = request.UserClientIp
985 }
986
987 if !dara.IsNil(request.Value) {
988 query["Value"] = request.Value
989 }
990
991 if !dara.IsNil(request.Weight) {
992 query["Weight"] = request.Weight
993 }
994
995 if !dara.IsNil(request.ZoneId) {
996 query["ZoneId"] = request.ZoneId
997 }
998
999 req := &openapiutil.OpenApiRequest{
1000 Query: openapiutil.Query(query),
1001 }
1002 params := &openapiutil.Params{
1003 Action: dara.String("AddRecursionRecord"),
1004 Version: dara.String("2015-01-09"),
1005 Protocol: dara.String("HTTPS"),
1006 Pathname: dara.String("/"),
1007 Method: dara.String("POST"),
1008 AuthType: dara.String("AK"),
1009 Style: dara.String("RPC"),
1010 ReqBodyType: dara.String("formData"),
1011 BodyType: dara.String("json"),
1012 }
1013 _result = &AddRecursionRecordResponse{}
1014 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1015 if _err != nil {
1016 return _result, _err
1017 }
1018 _err = dara.Convert(_body, &_result)
1019 return _result, _err
1020 }
1021
1022 // Summary:
1023 //
1024 // 新增递归解析内置权威域名zone
1025 //
1026 // @param request - AddRecursionZoneRequest
1027 //
1028 // @param runtime - runtime options for this request RuntimeOptions
1029 //
1030 // @return AddRecursionZoneResponse
1031 func AddRecursionZoneWithContext(ctx context.Context, client *Client, request *AddRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *AddRecursionZoneResponse, _err error) {
1032 if dara.BoolValue(client.EnableValidate) == true {
1033 _err = request.Validate()
1034 if _err != nil {
1035 return _result, _err
1036 }
1037 }
1038 query := map[string]interface{}{}
1039 if !dara.IsNil(request.ClientToken) {
1040 query["ClientToken"] = request.ClientToken
1041 }
1042
1043 if !dara.IsNil(request.ProxyPattern) {
1044 query["ProxyPattern"] = request.ProxyPattern
1045 }
1046
1047 if !dara.IsNil(request.ZoneName) {
1048 query["ZoneName"] = request.ZoneName
1049 }
1050
1051 req := &openapiutil.OpenApiRequest{
1052 Query: openapiutil.Query(query),
1053 }
1054 params := &openapiutil.Params{
1055 Action: dara.String("AddRecursionZone"),
1056 Version: dara.String("2015-01-09"),
1057 Protocol: dara.String("HTTPS"),
1058 Pathname: dara.String("/"),
1059 Method: dara.String("POST"),
1060 AuthType: dara.String("AK"),
1061 Style: dara.String("RPC"),
1062 ReqBodyType: dara.String("formData"),
1063 BodyType: dara.String("json"),
1064 }
1065 _result = &AddRecursionZoneResponse{}
1066 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1067 if _err != nil {
1068 return _result, _err
1069 }
1070 _err = dara.Convert(_body, &_result)
1071 return _result, _err
1072 }
1073
1074 // Summary:
1075 //
1076 // Binds one or more domain names to a paid Alibaba Cloud DNS instance.
1077 //
1078 // Description:
1079 //
1080 // 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.\\
1081 //
1082 // 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.
1083 //
1084 // @param request - BindInstanceDomainsRequest
1085 //
1086 // @param runtime - runtime options for this request RuntimeOptions
1087 //
1088 // @return BindInstanceDomainsResponse
1089 func BindInstanceDomainsWithContext(ctx context.Context, client *Client, request *BindInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *BindInstanceDomainsResponse, _err error) {
1090 if dara.BoolValue(client.EnableValidate) == true {
1091 _err = request.Validate()
1092 if _err != nil {
1093 return _result, _err
1094 }
1095 }
1096 query := map[string]interface{}{}
1097 if !dara.IsNil(request.DomainNames) {
1098 query["DomainNames"] = request.DomainNames
1099 }
1100
1101 if !dara.IsNil(request.InstanceId) {
1102 query["InstanceId"] = request.InstanceId
1103 }
1104
1105 if !dara.IsNil(request.Lang) {
1106 query["Lang"] = request.Lang
1107 }
1108
1109 req := &openapiutil.OpenApiRequest{
1110 Query: openapiutil.Query(query),
1111 }
1112 params := &openapiutil.Params{
1113 Action: dara.String("BindInstanceDomains"),
1114 Version: dara.String("2015-01-09"),
1115 Protocol: dara.String("HTTPS"),
1116 Pathname: dara.String("/"),
1117 Method: dara.String("POST"),
1118 AuthType: dara.String("AK"),
1119 Style: dara.String("RPC"),
1120 ReqBodyType: dara.String("formData"),
1121 BodyType: dara.String("json"),
1122 }
1123 _result = &BindInstanceDomainsResponse{}
1124 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1125 if _err != nil {
1126 return _result, _err
1127 }
1128 _err = dara.Convert(_body, &_result)
1129 return _result, _err
1130 }
1131
1132 // Summary:
1133 //
1134 // Moves a domain name from the original group to the new group based on the specified parameters.
1135 //
1136 // Description:
1137 //
1138 // 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.
1139 //
1140 // @param request - ChangeDomainGroupRequest
1141 //
1142 // @param runtime - runtime options for this request RuntimeOptions
1143 //
1144 // @return ChangeDomainGroupResponse
1145 func ChangeDomainGroupWithContext(ctx context.Context, client *Client, request *ChangeDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *ChangeDomainGroupResponse, _err error) {
1146 if dara.BoolValue(client.EnableValidate) == true {
1147 _err = request.Validate()
1148 if _err != nil {
1149 return _result, _err
1150 }
1151 }
1152 query := map[string]interface{}{}
1153 if !dara.IsNil(request.DomainName) {
1154 query["DomainName"] = request.DomainName
1155 }
1156
1157 if !dara.IsNil(request.GroupId) {
1158 query["GroupId"] = request.GroupId
1159 }
1160
1161 if !dara.IsNil(request.Lang) {
1162 query["Lang"] = request.Lang
1163 }
1164
1165 req := &openapiutil.OpenApiRequest{
1166 Query: openapiutil.Query(query),
1167 }
1168 params := &openapiutil.Params{
1169 Action: dara.String("ChangeDomainGroup"),
1170 Version: dara.String("2015-01-09"),
1171 Protocol: dara.String("HTTPS"),
1172 Pathname: dara.String("/"),
1173 Method: dara.String("POST"),
1174 AuthType: dara.String("AK"),
1175 Style: dara.String("RPC"),
1176 ReqBodyType: dara.String("formData"),
1177 BodyType: dara.String("json"),
1178 }
1179 _result = &ChangeDomainGroupResponse{}
1180 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1181 if _err != nil {
1182 return _result, _err
1183 }
1184 _err = dara.Convert(_body, &_result)
1185 return _result, _err
1186 }
1187
1188 // Summary:
1189 //
1190 // Changes the domain name that is bound to an Alibaba Cloud DNS instance.
1191 //
1192 // Description:
1193 //
1194 // **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.**
1195 //
1196 // - **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.
1197 //
1198 // @param request - ChangeDomainOfDnsProductRequest
1199 //
1200 // @param runtime - runtime options for this request RuntimeOptions
1201 //
1202 // @return ChangeDomainOfDnsProductResponse
1203 func ChangeDomainOfDnsProductWithContext(ctx context.Context, client *Client, request *ChangeDomainOfDnsProductRequest, runtime *dara.RuntimeOptions) (_result *ChangeDomainOfDnsProductResponse, _err error) {
1204 if dara.BoolValue(client.EnableValidate) == true {
1205 _err = request.Validate()
1206 if _err != nil {
1207 return _result, _err
1208 }
1209 }
1210 query := map[string]interface{}{}
1211 if !dara.IsNil(request.Force) {
1212 query["Force"] = request.Force
1213 }
1214
1215 if !dara.IsNil(request.InstanceId) {
1216 query["InstanceId"] = request.InstanceId
1217 }
1218
1219 if !dara.IsNil(request.Lang) {
1220 query["Lang"] = request.Lang
1221 }
1222
1223 if !dara.IsNil(request.NewDomain) {
1224 query["NewDomain"] = request.NewDomain
1225 }
1226
1227 if !dara.IsNil(request.UserClientIp) {
1228 query["UserClientIp"] = request.UserClientIp
1229 }
1230
1231 req := &openapiutil.OpenApiRequest{
1232 Query: openapiutil.Query(query),
1233 }
1234 params := &openapiutil.Params{
1235 Action: dara.String("ChangeDomainOfDnsProduct"),
1236 Version: dara.String("2015-01-09"),
1237 Protocol: dara.String("HTTPS"),
1238 Pathname: dara.String("/"),
1239 Method: dara.String("POST"),
1240 AuthType: dara.String("AK"),
1241 Style: dara.String("RPC"),
1242 ReqBodyType: dara.String("formData"),
1243 BodyType: dara.String("json"),
1244 }
1245 _result = &ChangeDomainOfDnsProductResponse{}
1246 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1247 if _err != nil {
1248 return _result, _err
1249 }
1250 _err = dara.Convert(_body, &_result)
1251 return _result, _err
1252 }
1253
1254 // Summary:
1255 //
1256 // Copies the configurations of a Global Traffic Manager (GTM) instance.
1257 //
1258 // @param request - CopyGtmConfigRequest
1259 //
1260 // @param runtime - runtime options for this request RuntimeOptions
1261 //
1262 // @return CopyGtmConfigResponse
1263 func CopyGtmConfigWithContext(ctx context.Context, client *Client, request *CopyGtmConfigRequest, runtime *dara.RuntimeOptions) (_result *CopyGtmConfigResponse, _err error) {
1264 if dara.BoolValue(client.EnableValidate) == true {
1265 _err = request.Validate()
1266 if _err != nil {
1267 return _result, _err
1268 }
1269 }
1270 query := map[string]interface{}{}
1271 if !dara.IsNil(request.CopyType) {
1272 query["CopyType"] = request.CopyType
1273 }
1274
1275 if !dara.IsNil(request.Lang) {
1276 query["Lang"] = request.Lang
1277 }
1278
1279 if !dara.IsNil(request.SourceId) {
1280 query["SourceId"] = request.SourceId
1281 }
1282
1283 if !dara.IsNil(request.TargetId) {
1284 query["TargetId"] = request.TargetId
1285 }
1286
1287 req := &openapiutil.OpenApiRequest{
1288 Query: openapiutil.Query(query),
1289 }
1290 params := &openapiutil.Params{
1291 Action: dara.String("CopyGtmConfig"),
1292 Version: dara.String("2015-01-09"),
1293 Protocol: dara.String("HTTPS"),
1294 Pathname: dara.String("/"),
1295 Method: dara.String("POST"),
1296 AuthType: dara.String("AK"),
1297 Style: dara.String("RPC"),
1298 ReqBodyType: dara.String("formData"),
1299 BodyType: dara.String("json"),
1300 }
1301 _result = &CopyGtmConfigResponse{}
1302 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1303 if _err != nil {
1304 return _result, _err
1305 }
1306 _err = dara.Convert(_body, &_result)
1307 return _result, _err
1308 }
1309
1310 // Summary:
1311 //
1312 // Creates an address.
1313 //
1314 // @param tmpReq - CreateCloudGtmAddressRequest
1315 //
1316 // @param runtime - runtime options for this request RuntimeOptions
1317 //
1318 // @return CreateCloudGtmAddressResponse
1319 func CreateCloudGtmAddressWithContext(ctx context.Context, client *Client, tmpReq *CreateCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmAddressResponse, _err error) {
1320 if dara.BoolValue(client.EnableValidate) == true {
1321 _err = tmpReq.Validate()
1322 if _err != nil {
1323 return _result, _err
1324 }
1325 }
1326 request := &CreateCloudGtmAddressShrinkRequest{}
1327 openapiutil.Convert(tmpReq, request)
1328 if !dara.IsNil(tmpReq.HealthTasks) {
1329 request.HealthTasksShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HealthTasks, dara.String("HealthTasks"), dara.String("json"))
1330 }
1331
1332 query := map[string]interface{}{}
1333 if !dara.IsNil(request.AcceptLanguage) {
1334 query["AcceptLanguage"] = request.AcceptLanguage
1335 }
1336
1337 if !dara.IsNil(request.Address) {
1338 query["Address"] = request.Address
1339 }
1340
1341 if !dara.IsNil(request.AttributeInfo) {
1342 query["AttributeInfo"] = request.AttributeInfo
1343 }
1344
1345 if !dara.IsNil(request.AvailableMode) {
1346 query["AvailableMode"] = request.AvailableMode
1347 }
1348
1349 if !dara.IsNil(request.ClientToken) {
1350 query["ClientToken"] = request.ClientToken
1351 }
1352
1353 if !dara.IsNil(request.EnableStatus) {
1354 query["EnableStatus"] = request.EnableStatus
1355 }
1356
1357 if !dara.IsNil(request.HealthJudgement) {
1358 query["HealthJudgement"] = request.HealthJudgement
1359 }
1360
1361 if !dara.IsNil(request.HealthTasksShrink) {
1362 query["HealthTasks"] = request.HealthTasksShrink
1363 }
1364
1365 if !dara.IsNil(request.ManualAvailableStatus) {
1366 query["ManualAvailableStatus"] = request.ManualAvailableStatus
1367 }
1368
1369 if !dara.IsNil(request.Name) {
1370 query["Name"] = request.Name
1371 }
1372
1373 if !dara.IsNil(request.Remark) {
1374 query["Remark"] = request.Remark
1375 }
1376
1377 if !dara.IsNil(request.Type) {
1378 query["Type"] = request.Type
1379 }
1380
1381 req := &openapiutil.OpenApiRequest{
1382 Query: openapiutil.Query(query),
1383 }
1384 params := &openapiutil.Params{
1385 Action: dara.String("CreateCloudGtmAddress"),
1386 Version: dara.String("2015-01-09"),
1387 Protocol: dara.String("HTTPS"),
1388 Pathname: dara.String("/"),
1389 Method: dara.String("POST"),
1390 AuthType: dara.String("AK"),
1391 Style: dara.String("RPC"),
1392 ReqBodyType: dara.String("formData"),
1393 BodyType: dara.String("json"),
1394 }
1395 _result = &CreateCloudGtmAddressResponse{}
1396 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1397 if _err != nil {
1398 return _result, _err
1399 }
1400 _err = dara.Convert(_body, &_result)
1401 return _result, _err
1402 }
1403
1404 // Summary:
1405 //
1406 // Creates an address pool.
1407 //
1408 // @param request - CreateCloudGtmAddressPoolRequest
1409 //
1410 // @param runtime - runtime options for this request RuntimeOptions
1411 //
1412 // @return CreateCloudGtmAddressPoolResponse
1413 func CreateCloudGtmAddressPoolWithContext(ctx context.Context, client *Client, request *CreateCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmAddressPoolResponse, _err error) {
1414 if dara.BoolValue(client.EnableValidate) == true {
1415 _err = request.Validate()
1416 if _err != nil {
1417 return _result, _err
1418 }
1419 }
1420 query := map[string]interface{}{}
1421 if !dara.IsNil(request.AcceptLanguage) {
1422 query["AcceptLanguage"] = request.AcceptLanguage
1423 }
1424
1425 if !dara.IsNil(request.AddressPoolName) {
1426 query["AddressPoolName"] = request.AddressPoolName
1427 }
1428
1429 if !dara.IsNil(request.AddressPoolType) {
1430 query["AddressPoolType"] = request.AddressPoolType
1431 }
1432
1433 if !dara.IsNil(request.ClientToken) {
1434 query["ClientToken"] = request.ClientToken
1435 }
1436
1437 if !dara.IsNil(request.EnableStatus) {
1438 query["EnableStatus"] = request.EnableStatus
1439 }
1440
1441 if !dara.IsNil(request.HealthJudgement) {
1442 query["HealthJudgement"] = request.HealthJudgement
1443 }
1444
1445 if !dara.IsNil(request.Remark) {
1446 query["Remark"] = request.Remark
1447 }
1448
1449 req := &openapiutil.OpenApiRequest{
1450 Query: openapiutil.Query(query),
1451 }
1452 params := &openapiutil.Params{
1453 Action: dara.String("CreateCloudGtmAddressPool"),
1454 Version: dara.String("2015-01-09"),
1455 Protocol: dara.String("HTTPS"),
1456 Pathname: dara.String("/"),
1457 Method: dara.String("POST"),
1458 AuthType: dara.String("AK"),
1459 Style: dara.String("RPC"),
1460 ReqBodyType: dara.String("formData"),
1461 BodyType: dara.String("json"),
1462 }
1463 _result = &CreateCloudGtmAddressPoolResponse{}
1464 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1465 if _err != nil {
1466 return _result, _err
1467 }
1468 _err = dara.Convert(_body, &_result)
1469 return _result, _err
1470 }
1471
1472 // Summary:
1473 //
1474 // 创建gtm实例配置
1475 //
1476 // @param request - CreateCloudGtmInstanceConfigRequest
1477 //
1478 // @param runtime - runtime options for this request RuntimeOptions
1479 //
1480 // @return CreateCloudGtmInstanceConfigResponse
1481 func CreateCloudGtmInstanceConfigWithContext(ctx context.Context, client *Client, request *CreateCloudGtmInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmInstanceConfigResponse, _err error) {
1482 if dara.BoolValue(client.EnableValidate) == true {
1483 _err = request.Validate()
1484 if _err != nil {
1485 return _result, _err
1486 }
1487 }
1488 query := map[string]interface{}{}
1489 if !dara.IsNil(request.AcceptLanguage) {
1490 query["AcceptLanguage"] = request.AcceptLanguage
1491 }
1492
1493 if !dara.IsNil(request.ChargeType) {
1494 query["ChargeType"] = request.ChargeType
1495 }
1496
1497 if !dara.IsNil(request.ClientToken) {
1498 query["ClientToken"] = request.ClientToken
1499 }
1500
1501 if !dara.IsNil(request.EnableStatus) {
1502 query["EnableStatus"] = request.EnableStatus
1503 }
1504
1505 if !dara.IsNil(request.InstanceId) {
1506 query["InstanceId"] = request.InstanceId
1507 }
1508
1509 if !dara.IsNil(request.Remark) {
1510 query["Remark"] = request.Remark
1511 }
1512
1513 if !dara.IsNil(request.ScheduleHostname) {
1514 query["ScheduleHostname"] = request.ScheduleHostname
1515 }
1516
1517 if !dara.IsNil(request.ScheduleRrType) {
1518 query["ScheduleRrType"] = request.ScheduleRrType
1519 }
1520
1521 if !dara.IsNil(request.ScheduleZoneMode) {
1522 query["ScheduleZoneMode"] = request.ScheduleZoneMode
1523 }
1524
1525 if !dara.IsNil(request.ScheduleZoneName) {
1526 query["ScheduleZoneName"] = request.ScheduleZoneName
1527 }
1528
1529 if !dara.IsNil(request.Ttl) {
1530 query["Ttl"] = request.Ttl
1531 }
1532
1533 req := &openapiutil.OpenApiRequest{
1534 Query: openapiutil.Query(query),
1535 }
1536 params := &openapiutil.Params{
1537 Action: dara.String("CreateCloudGtmInstanceConfig"),
1538 Version: dara.String("2015-01-09"),
1539 Protocol: dara.String("HTTPS"),
1540 Pathname: dara.String("/"),
1541 Method: dara.String("POST"),
1542 AuthType: dara.String("AK"),
1543 Style: dara.String("RPC"),
1544 ReqBodyType: dara.String("formData"),
1545 BodyType: dara.String("json"),
1546 }
1547 _result = &CreateCloudGtmInstanceConfigResponse{}
1548 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1549 if _err != nil {
1550 return _result, _err
1551 }
1552 _err = dara.Convert(_body, &_result)
1553 return _result, _err
1554 }
1555
1556 // Summary:
1557 //
1558 // Creates a health check template.
1559 //
1560 // @param tmpReq - CreateCloudGtmMonitorTemplateRequest
1561 //
1562 // @param runtime - runtime options for this request RuntimeOptions
1563 //
1564 // @return CreateCloudGtmMonitorTemplateResponse
1565 func CreateCloudGtmMonitorTemplateWithContext(ctx context.Context, client *Client, tmpReq *CreateCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *CreateCloudGtmMonitorTemplateResponse, _err error) {
1566 if dara.BoolValue(client.EnableValidate) == true {
1567 _err = tmpReq.Validate()
1568 if _err != nil {
1569 return _result, _err
1570 }
1571 }
1572 request := &CreateCloudGtmMonitorTemplateShrinkRequest{}
1573 openapiutil.Convert(tmpReq, request)
1574 if !dara.IsNil(tmpReq.IspCityNodes) {
1575 request.IspCityNodesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.IspCityNodes, dara.String("IspCityNodes"), dara.String("json"))
1576 }
1577
1578 query := map[string]interface{}{}
1579 if !dara.IsNil(request.AcceptLanguage) {
1580 query["AcceptLanguage"] = request.AcceptLanguage
1581 }
1582
1583 if !dara.IsNil(request.ClientToken) {
1584 query["ClientToken"] = request.ClientToken
1585 }
1586
1587 if !dara.IsNil(request.EvaluationCount) {
1588 query["EvaluationCount"] = request.EvaluationCount
1589 }
1590
1591 if !dara.IsNil(request.ExtendInfo) {
1592 query["ExtendInfo"] = request.ExtendInfo
1593 }
1594
1595 if !dara.IsNil(request.FailureRate) {
1596 query["FailureRate"] = request.FailureRate
1597 }
1598
1599 if !dara.IsNil(request.Interval) {
1600 query["Interval"] = request.Interval
1601 }
1602
1603 if !dara.IsNil(request.IpVersion) {
1604 query["IpVersion"] = request.IpVersion
1605 }
1606
1607 if !dara.IsNil(request.IspCityNodesShrink) {
1608 query["IspCityNodes"] = request.IspCityNodesShrink
1609 }
1610
1611 if !dara.IsNil(request.Name) {
1612 query["Name"] = request.Name
1613 }
1614
1615 if !dara.IsNil(request.Protocol) {
1616 query["Protocol"] = request.Protocol
1617 }
1618
1619 if !dara.IsNil(request.Timeout) {
1620 query["Timeout"] = request.Timeout
1621 }
1622
1623 req := &openapiutil.OpenApiRequest{
1624 Query: openapiutil.Query(query),
1625 }
1626 params := &openapiutil.Params{
1627 Action: dara.String("CreateCloudGtmMonitorTemplate"),
1628 Version: dara.String("2015-01-09"),
1629 Protocol: dara.String("HTTPS"),
1630 Pathname: dara.String("/"),
1631 Method: dara.String("POST"),
1632 AuthType: dara.String("AK"),
1633 Style: dara.String("RPC"),
1634 ReqBodyType: dara.String("formData"),
1635 BodyType: dara.String("json"),
1636 }
1637 _result = &CreateCloudGtmMonitorTemplateResponse{}
1638 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1639 if _err != nil {
1640 return _result, _err
1641 }
1642 _err = dara.Convert(_body, &_result)
1643 return _result, _err
1644 }
1645
1646 // Summary:
1647 //
1648 // 创建公共DNS AppKey
1649 //
1650 // @param request - CreatePdnsAppKeyRequest
1651 //
1652 // @param runtime - runtime options for this request RuntimeOptions
1653 //
1654 // @return CreatePdnsAppKeyResponse
1655 func CreatePdnsAppKeyWithContext(ctx context.Context, client *Client, request *CreatePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *CreatePdnsAppKeyResponse, _err error) {
1656 if dara.BoolValue(client.EnableValidate) == true {
1657 _err = request.Validate()
1658 if _err != nil {
1659 return _result, _err
1660 }
1661 }
1662 query := map[string]interface{}{}
1663 if !dara.IsNil(request.Lang) {
1664 query["Lang"] = request.Lang
1665 }
1666
1667 if !dara.IsNil(request.Remark) {
1668 query["Remark"] = request.Remark
1669 }
1670
1671 req := &openapiutil.OpenApiRequest{
1672 Query: openapiutil.Query(query),
1673 }
1674 params := &openapiutil.Params{
1675 Action: dara.String("CreatePdnsAppKey"),
1676 Version: dara.String("2015-01-09"),
1677 Protocol: dara.String("HTTPS"),
1678 Pathname: dara.String("/"),
1679 Method: dara.String("POST"),
1680 AuthType: dara.String("AK"),
1681 Style: dara.String("RPC"),
1682 ReqBodyType: dara.String("formData"),
1683 BodyType: dara.String("json"),
1684 }
1685 _result = &CreatePdnsAppKeyResponse{}
1686 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1687 if _err != nil {
1688 return _result, _err
1689 }
1690 _err = dara.Convert(_body, &_result)
1691 return _result, _err
1692 }
1693
1694 // Summary:
1695 //
1696 // 创建公共DNS Udp Ip地址段
1697 //
1698 // @param request - CreatePdnsUdpIpSegmentRequest
1699 //
1700 // @param runtime - runtime options for this request RuntimeOptions
1701 //
1702 // @return CreatePdnsUdpIpSegmentResponse
1703 func CreatePdnsUdpIpSegmentWithContext(ctx context.Context, client *Client, request *CreatePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *CreatePdnsUdpIpSegmentResponse, _err error) {
1704 if dara.BoolValue(client.EnableValidate) == true {
1705 _err = request.Validate()
1706 if _err != nil {
1707 return _result, _err
1708 }
1709 }
1710 query := map[string]interface{}{}
1711 if !dara.IsNil(request.Ip) {
1712 query["Ip"] = request.Ip
1713 }
1714
1715 if !dara.IsNil(request.IpToken) {
1716 query["IpToken"] = request.IpToken
1717 }
1718
1719 if !dara.IsNil(request.Lang) {
1720 query["Lang"] = request.Lang
1721 }
1722
1723 if !dara.IsNil(request.Name) {
1724 query["Name"] = request.Name
1725 }
1726
1727 req := &openapiutil.OpenApiRequest{
1728 Query: openapiutil.Query(query),
1729 }
1730 params := &openapiutil.Params{
1731 Action: dara.String("CreatePdnsUdpIpSegment"),
1732 Version: dara.String("2015-01-09"),
1733 Protocol: dara.String("HTTPS"),
1734 Pathname: dara.String("/"),
1735 Method: dara.String("POST"),
1736 AuthType: dara.String("AK"),
1737 Style: dara.String("RPC"),
1738 ReqBodyType: dara.String("formData"),
1739 BodyType: dara.String("json"),
1740 }
1741 _result = &CreatePdnsUdpIpSegmentResponse{}
1742 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1743 if _err != nil {
1744 return _result, _err
1745 }
1746 _err = dara.Convert(_body, &_result)
1747 return _result, _err
1748 }
1749
1750 // Summary:
1751 //
1752 // Deletes an address.
1753 //
1754 // @param request - DeleteCloudGtmAddressRequest
1755 //
1756 // @param runtime - runtime options for this request RuntimeOptions
1757 //
1758 // @return DeleteCloudGtmAddressResponse
1759 func DeleteCloudGtmAddressWithContext(ctx context.Context, client *Client, request *DeleteCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmAddressResponse, _err error) {
1760 if dara.BoolValue(client.EnableValidate) == true {
1761 _err = request.Validate()
1762 if _err != nil {
1763 return _result, _err
1764 }
1765 }
1766 query := map[string]interface{}{}
1767 if !dara.IsNil(request.AcceptLanguage) {
1768 query["AcceptLanguage"] = request.AcceptLanguage
1769 }
1770
1771 if !dara.IsNil(request.AddressId) {
1772 query["AddressId"] = request.AddressId
1773 }
1774
1775 if !dara.IsNil(request.ClientToken) {
1776 query["ClientToken"] = request.ClientToken
1777 }
1778
1779 req := &openapiutil.OpenApiRequest{
1780 Query: openapiutil.Query(query),
1781 }
1782 params := &openapiutil.Params{
1783 Action: dara.String("DeleteCloudGtmAddress"),
1784 Version: dara.String("2015-01-09"),
1785 Protocol: dara.String("HTTPS"),
1786 Pathname: dara.String("/"),
1787 Method: dara.String("POST"),
1788 AuthType: dara.String("AK"),
1789 Style: dara.String("RPC"),
1790 ReqBodyType: dara.String("formData"),
1791 BodyType: dara.String("json"),
1792 }
1793 _result = &DeleteCloudGtmAddressResponse{}
1794 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1795 if _err != nil {
1796 return _result, _err
1797 }
1798 _err = dara.Convert(_body, &_result)
1799 return _result, _err
1800 }
1801
1802 // Summary:
1803 //
1804 // Deletes an address pool.
1805 //
1806 // @param request - DeleteCloudGtmAddressPoolRequest
1807 //
1808 // @param runtime - runtime options for this request RuntimeOptions
1809 //
1810 // @return DeleteCloudGtmAddressPoolResponse
1811 func DeleteCloudGtmAddressPoolWithContext(ctx context.Context, client *Client, request *DeleteCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmAddressPoolResponse, _err error) {
1812 if dara.BoolValue(client.EnableValidate) == true {
1813 _err = request.Validate()
1814 if _err != nil {
1815 return _result, _err
1816 }
1817 }
1818 query := map[string]interface{}{}
1819 if !dara.IsNil(request.AcceptLanguage) {
1820 query["AcceptLanguage"] = request.AcceptLanguage
1821 }
1822
1823 if !dara.IsNil(request.AddressPoolId) {
1824 query["AddressPoolId"] = request.AddressPoolId
1825 }
1826
1827 if !dara.IsNil(request.ClientToken) {
1828 query["ClientToken"] = request.ClientToken
1829 }
1830
1831 req := &openapiutil.OpenApiRequest{
1832 Query: openapiutil.Query(query),
1833 }
1834 params := &openapiutil.Params{
1835 Action: dara.String("DeleteCloudGtmAddressPool"),
1836 Version: dara.String("2015-01-09"),
1837 Protocol: dara.String("HTTPS"),
1838 Pathname: dara.String("/"),
1839 Method: dara.String("POST"),
1840 AuthType: dara.String("AK"),
1841 Style: dara.String("RPC"),
1842 ReqBodyType: dara.String("formData"),
1843 BodyType: dara.String("json"),
1844 }
1845 _result = &DeleteCloudGtmAddressPoolResponse{}
1846 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1847 if _err != nil {
1848 return _result, _err
1849 }
1850 _err = dara.Convert(_body, &_result)
1851 return _result, _err
1852 }
1853
1854 // Summary:
1855 //
1856 // Deletes an access domain name that is configured for a Global Traffic Manager (GTM) 3.0 instance.
1857 //
1858 // @param request - DeleteCloudGtmInstanceConfigRequest
1859 //
1860 // @param runtime - runtime options for this request RuntimeOptions
1861 //
1862 // @return DeleteCloudGtmInstanceConfigResponse
1863 func DeleteCloudGtmInstanceConfigWithContext(ctx context.Context, client *Client, request *DeleteCloudGtmInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmInstanceConfigResponse, _err error) {
1864 if dara.BoolValue(client.EnableValidate) == true {
1865 _err = request.Validate()
1866 if _err != nil {
1867 return _result, _err
1868 }
1869 }
1870 query := map[string]interface{}{}
1871 if !dara.IsNil(request.AcceptLanguage) {
1872 query["AcceptLanguage"] = request.AcceptLanguage
1873 }
1874
1875 if !dara.IsNil(request.ClientToken) {
1876 query["ClientToken"] = request.ClientToken
1877 }
1878
1879 if !dara.IsNil(request.ConfigId) {
1880 query["ConfigId"] = request.ConfigId
1881 }
1882
1883 if !dara.IsNil(request.InstanceId) {
1884 query["InstanceId"] = request.InstanceId
1885 }
1886
1887 req := &openapiutil.OpenApiRequest{
1888 Query: openapiutil.Query(query),
1889 }
1890 params := &openapiutil.Params{
1891 Action: dara.String("DeleteCloudGtmInstanceConfig"),
1892 Version: dara.String("2015-01-09"),
1893 Protocol: dara.String("HTTPS"),
1894 Pathname: dara.String("/"),
1895 Method: dara.String("POST"),
1896 AuthType: dara.String("AK"),
1897 Style: dara.String("RPC"),
1898 ReqBodyType: dara.String("formData"),
1899 BodyType: dara.String("json"),
1900 }
1901 _result = &DeleteCloudGtmInstanceConfigResponse{}
1902 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1903 if _err != nil {
1904 return _result, _err
1905 }
1906 _err = dara.Convert(_body, &_result)
1907 return _result, _err
1908 }
1909
1910 // Summary:
1911 //
1912 // Deletes a health check template.
1913 //
1914 // @param request - DeleteCloudGtmMonitorTemplateRequest
1915 //
1916 // @param runtime - runtime options for this request RuntimeOptions
1917 //
1918 // @return DeleteCloudGtmMonitorTemplateResponse
1919 func DeleteCloudGtmMonitorTemplateWithContext(ctx context.Context, client *Client, request *DeleteCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *DeleteCloudGtmMonitorTemplateResponse, _err error) {
1920 if dara.BoolValue(client.EnableValidate) == true {
1921 _err = request.Validate()
1922 if _err != nil {
1923 return _result, _err
1924 }
1925 }
1926 query := map[string]interface{}{}
1927 if !dara.IsNil(request.AcceptLanguage) {
1928 query["AcceptLanguage"] = request.AcceptLanguage
1929 }
1930
1931 if !dara.IsNil(request.ClientToken) {
1932 query["ClientToken"] = request.ClientToken
1933 }
1934
1935 if !dara.IsNil(request.TemplateId) {
1936 query["TemplateId"] = request.TemplateId
1937 }
1938
1939 req := &openapiutil.OpenApiRequest{
1940 Query: openapiutil.Query(query),
1941 }
1942 params := &openapiutil.Params{
1943 Action: dara.String("DeleteCloudGtmMonitorTemplate"),
1944 Version: dara.String("2015-01-09"),
1945 Protocol: dara.String("HTTPS"),
1946 Pathname: dara.String("/"),
1947 Method: dara.String("POST"),
1948 AuthType: dara.String("AK"),
1949 Style: dara.String("RPC"),
1950 ReqBodyType: dara.String("formData"),
1951 BodyType: dara.String("json"),
1952 }
1953 _result = &DeleteCloudGtmMonitorTemplateResponse{}
1954 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1955 if _err != nil {
1956 return _result, _err
1957 }
1958 _err = dara.Convert(_body, &_result)
1959 return _result, _err
1960 }
1961
1962 // Summary:
1963 //
1964 // Deletes custom lines at a time by using the unique IDs.
1965 //
1966 // @param request - DeleteCustomLinesRequest
1967 //
1968 // @param runtime - runtime options for this request RuntimeOptions
1969 //
1970 // @return DeleteCustomLinesResponse
1971 func DeleteCustomLinesWithContext(ctx context.Context, client *Client, request *DeleteCustomLinesRequest, runtime *dara.RuntimeOptions) (_result *DeleteCustomLinesResponse, _err error) {
1972 if dara.BoolValue(client.EnableValidate) == true {
1973 _err = request.Validate()
1974 if _err != nil {
1975 return _result, _err
1976 }
1977 }
1978 query := map[string]interface{}{}
1979 if !dara.IsNil(request.Lang) {
1980 query["Lang"] = request.Lang
1981 }
1982
1983 if !dara.IsNil(request.LineIds) {
1984 query["LineIds"] = request.LineIds
1985 }
1986
1987 req := &openapiutil.OpenApiRequest{
1988 Query: openapiutil.Query(query),
1989 }
1990 params := &openapiutil.Params{
1991 Action: dara.String("DeleteCustomLines"),
1992 Version: dara.String("2015-01-09"),
1993 Protocol: dara.String("HTTPS"),
1994 Pathname: dara.String("/"),
1995 Method: dara.String("POST"),
1996 AuthType: dara.String("AK"),
1997 Style: dara.String("RPC"),
1998 ReqBodyType: dara.String("formData"),
1999 BodyType: dara.String("json"),
2000 }
2001 _result = &DeleteCustomLinesResponse{}
2002 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2003 if _err != nil {
2004 return _result, _err
2005 }
2006 _err = dara.Convert(_body, &_result)
2007 return _result, _err
2008 }
2009
2010 // Summary:
2011 //
2012 // Deletes a specified cache-accelerated domain name.
2013 //
2014 // @param request - DeleteDnsCacheDomainRequest
2015 //
2016 // @param runtime - runtime options for this request RuntimeOptions
2017 //
2018 // @return DeleteDnsCacheDomainResponse
2019 func DeleteDnsCacheDomainWithContext(ctx context.Context, client *Client, request *DeleteDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsCacheDomainResponse, _err error) {
2020 if dara.BoolValue(client.EnableValidate) == true {
2021 _err = request.Validate()
2022 if _err != nil {
2023 return _result, _err
2024 }
2025 }
2026 query := map[string]interface{}{}
2027 if !dara.IsNil(request.DomainName) {
2028 query["DomainName"] = request.DomainName
2029 }
2030
2031 if !dara.IsNil(request.Lang) {
2032 query["Lang"] = request.Lang
2033 }
2034
2035 req := &openapiutil.OpenApiRequest{
2036 Query: openapiutil.Query(query),
2037 }
2038 params := &openapiutil.Params{
2039 Action: dara.String("DeleteDnsCacheDomain"),
2040 Version: dara.String("2015-01-09"),
2041 Protocol: dara.String("HTTPS"),
2042 Pathname: dara.String("/"),
2043 Method: dara.String("POST"),
2044 AuthType: dara.String("AK"),
2045 Style: dara.String("RPC"),
2046 ReqBodyType: dara.String("formData"),
2047 BodyType: dara.String("json"),
2048 }
2049 _result = &DeleteDnsCacheDomainResponse{}
2050 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2051 if _err != nil {
2052 return _result, _err
2053 }
2054 _err = dara.Convert(_body, &_result)
2055 return _result, _err
2056 }
2057
2058 // @param request - DeleteDnsGtmAccessStrategyRequest
2059 //
2060 // @param runtime - runtime options for this request RuntimeOptions
2061 //
2062 // @return DeleteDnsGtmAccessStrategyResponse
2063 func DeleteDnsGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *DeleteDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsGtmAccessStrategyResponse, _err error) {
2064 if dara.BoolValue(client.EnableValidate) == true {
2065 _err = request.Validate()
2066 if _err != nil {
2067 return _result, _err
2068 }
2069 }
2070 query := map[string]interface{}{}
2071 if !dara.IsNil(request.Lang) {
2072 query["Lang"] = request.Lang
2073 }
2074
2075 if !dara.IsNil(request.StrategyId) {
2076 query["StrategyId"] = request.StrategyId
2077 }
2078
2079 req := &openapiutil.OpenApiRequest{
2080 Query: openapiutil.Query(query),
2081 }
2082 params := &openapiutil.Params{
2083 Action: dara.String("DeleteDnsGtmAccessStrategy"),
2084 Version: dara.String("2015-01-09"),
2085 Protocol: dara.String("HTTPS"),
2086 Pathname: dara.String("/"),
2087 Method: dara.String("POST"),
2088 AuthType: dara.String("AK"),
2089 Style: dara.String("RPC"),
2090 ReqBodyType: dara.String("formData"),
2091 BodyType: dara.String("json"),
2092 }
2093 _result = &DeleteDnsGtmAccessStrategyResponse{}
2094 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2095 if _err != nil {
2096 return _result, _err
2097 }
2098 _err = dara.Convert(_body, &_result)
2099 return _result, _err
2100 }
2101
2102 // @param request - DeleteDnsGtmAddressPoolRequest
2103 //
2104 // @param runtime - runtime options for this request RuntimeOptions
2105 //
2106 // @return DeleteDnsGtmAddressPoolResponse
2107 func DeleteDnsGtmAddressPoolWithContext(ctx context.Context, client *Client, request *DeleteDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteDnsGtmAddressPoolResponse, _err error) {
2108 if dara.BoolValue(client.EnableValidate) == true {
2109 _err = request.Validate()
2110 if _err != nil {
2111 return _result, _err
2112 }
2113 }
2114 query := map[string]interface{}{}
2115 if !dara.IsNil(request.AddrPoolId) {
2116 query["AddrPoolId"] = request.AddrPoolId
2117 }
2118
2119 if !dara.IsNil(request.Lang) {
2120 query["Lang"] = request.Lang
2121 }
2122
2123 req := &openapiutil.OpenApiRequest{
2124 Query: openapiutil.Query(query),
2125 }
2126 params := &openapiutil.Params{
2127 Action: dara.String("DeleteDnsGtmAddressPool"),
2128 Version: dara.String("2015-01-09"),
2129 Protocol: dara.String("HTTPS"),
2130 Pathname: dara.String("/"),
2131 Method: dara.String("POST"),
2132 AuthType: dara.String("AK"),
2133 Style: dara.String("RPC"),
2134 ReqBodyType: dara.String("formData"),
2135 BodyType: dara.String("json"),
2136 }
2137 _result = &DeleteDnsGtmAddressPoolResponse{}
2138 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2139 if _err != nil {
2140 return _result, _err
2141 }
2142 _err = dara.Convert(_body, &_result)
2143 return _result, _err
2144 }
2145
2146 // Summary:
2147 //
2148 // Deletes a domain name based on the specified parameters.
2149 //
2150 // @param request - DeleteDomainRequest
2151 //
2152 // @param runtime - runtime options for this request RuntimeOptions
2153 //
2154 // @return DeleteDomainResponse
2155 func DeleteDomainWithContext(ctx context.Context, client *Client, request *DeleteDomainRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainResponse, _err error) {
2156 if dara.BoolValue(client.EnableValidate) == true {
2157 _err = request.Validate()
2158 if _err != nil {
2159 return _result, _err
2160 }
2161 }
2162 query := map[string]interface{}{}
2163 if !dara.IsNil(request.DomainName) {
2164 query["DomainName"] = request.DomainName
2165 }
2166
2167 if !dara.IsNil(request.Lang) {
2168 query["Lang"] = request.Lang
2169 }
2170
2171 req := &openapiutil.OpenApiRequest{
2172 Query: openapiutil.Query(query),
2173 }
2174 params := &openapiutil.Params{
2175 Action: dara.String("DeleteDomain"),
2176 Version: dara.String("2015-01-09"),
2177 Protocol: dara.String("HTTPS"),
2178 Pathname: dara.String("/"),
2179 Method: dara.String("POST"),
2180 AuthType: dara.String("AK"),
2181 Style: dara.String("RPC"),
2182 ReqBodyType: dara.String("formData"),
2183 BodyType: dara.String("json"),
2184 }
2185 _result = &DeleteDomainResponse{}
2186 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2187 if _err != nil {
2188 return _result, _err
2189 }
2190 _err = dara.Convert(_body, &_result)
2191 return _result, _err
2192 }
2193
2194 // Summary:
2195 //
2196 // Deletes a domain name group. After you delete the domain name group, the domain names in the group are moved to the default group.
2197 //
2198 // Description:
2199 //
2200 // > The default group cannot be deleted.
2201 //
2202 // @param request - DeleteDomainGroupRequest
2203 //
2204 // @param runtime - runtime options for this request RuntimeOptions
2205 //
2206 // @return DeleteDomainGroupResponse
2207 func DeleteDomainGroupWithContext(ctx context.Context, client *Client, request *DeleteDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainGroupResponse, _err error) {
2208 if dara.BoolValue(client.EnableValidate) == true {
2209 _err = request.Validate()
2210 if _err != nil {
2211 return _result, _err
2212 }
2213 }
2214 query := map[string]interface{}{}
2215 if !dara.IsNil(request.GroupId) {
2216 query["GroupId"] = request.GroupId
2217 }
2218
2219 if !dara.IsNil(request.Lang) {
2220 query["Lang"] = request.Lang
2221 }
2222
2223 req := &openapiutil.OpenApiRequest{
2224 Query: openapiutil.Query(query),
2225 }
2226 params := &openapiutil.Params{
2227 Action: dara.String("DeleteDomainGroup"),
2228 Version: dara.String("2015-01-09"),
2229 Protocol: dara.String("HTTPS"),
2230 Pathname: dara.String("/"),
2231 Method: dara.String("POST"),
2232 AuthType: dara.String("AK"),
2233 Style: dara.String("RPC"),
2234 ReqBodyType: dara.String("formData"),
2235 BodyType: dara.String("json"),
2236 }
2237 _result = &DeleteDomainGroupResponse{}
2238 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2239 if _err != nil {
2240 return _result, _err
2241 }
2242 _err = dara.Convert(_body, &_result)
2243 return _result, _err
2244 }
2245
2246 // Summary:
2247 //
2248 // Deletes an Alibaba Cloud DNS (DNS) record based on the specified parameters.
2249 //
2250 // @param request - DeleteDomainRecordRequest
2251 //
2252 // @param runtime - runtime options for this request RuntimeOptions
2253 //
2254 // @return DeleteDomainRecordResponse
2255 func DeleteDomainRecordWithContext(ctx context.Context, client *Client, request *DeleteDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteDomainRecordResponse, _err error) {
2256 if dara.BoolValue(client.EnableValidate) == true {
2257 _err = request.Validate()
2258 if _err != nil {
2259 return _result, _err
2260 }
2261 }
2262 query := map[string]interface{}{}
2263 if !dara.IsNil(request.Lang) {
2264 query["Lang"] = request.Lang
2265 }
2266
2267 if !dara.IsNil(request.RecordId) {
2268 query["RecordId"] = request.RecordId
2269 }
2270
2271 if !dara.IsNil(request.UserClientIp) {
2272 query["UserClientIp"] = request.UserClientIp
2273 }
2274
2275 req := &openapiutil.OpenApiRequest{
2276 Query: openapiutil.Query(query),
2277 }
2278 params := &openapiutil.Params{
2279 Action: dara.String("DeleteDomainRecord"),
2280 Version: dara.String("2015-01-09"),
2281 Protocol: dara.String("HTTPS"),
2282 Pathname: dara.String("/"),
2283 Method: dara.String("POST"),
2284 AuthType: dara.String("AK"),
2285 Style: dara.String("RPC"),
2286 ReqBodyType: dara.String("formData"),
2287 BodyType: dara.String("json"),
2288 }
2289 _result = &DeleteDomainRecordResponse{}
2290 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2291 if _err != nil {
2292 return _result, _err
2293 }
2294 _err = dara.Convert(_body, &_result)
2295 return _result, _err
2296 }
2297
2298 // @param request - DeleteGtmAccessStrategyRequest
2299 //
2300 // @param runtime - runtime options for this request RuntimeOptions
2301 //
2302 // @return DeleteGtmAccessStrategyResponse
2303 func DeleteGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *DeleteGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmAccessStrategyResponse, _err error) {
2304 if dara.BoolValue(client.EnableValidate) == true {
2305 _err = request.Validate()
2306 if _err != nil {
2307 return _result, _err
2308 }
2309 }
2310 query := map[string]interface{}{}
2311 if !dara.IsNil(request.Lang) {
2312 query["Lang"] = request.Lang
2313 }
2314
2315 if !dara.IsNil(request.StrategyId) {
2316 query["StrategyId"] = request.StrategyId
2317 }
2318
2319 req := &openapiutil.OpenApiRequest{
2320 Query: openapiutil.Query(query),
2321 }
2322 params := &openapiutil.Params{
2323 Action: dara.String("DeleteGtmAccessStrategy"),
2324 Version: dara.String("2015-01-09"),
2325 Protocol: dara.String("HTTPS"),
2326 Pathname: dara.String("/"),
2327 Method: dara.String("POST"),
2328 AuthType: dara.String("AK"),
2329 Style: dara.String("RPC"),
2330 ReqBodyType: dara.String("formData"),
2331 BodyType: dara.String("json"),
2332 }
2333 _result = &DeleteGtmAccessStrategyResponse{}
2334 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2335 if _err != nil {
2336 return _result, _err
2337 }
2338 _err = dara.Convert(_body, &_result)
2339 return _result, _err
2340 }
2341
2342 // @param request - DeleteGtmAddressPoolRequest
2343 //
2344 // @param runtime - runtime options for this request RuntimeOptions
2345 //
2346 // @return DeleteGtmAddressPoolResponse
2347 func DeleteGtmAddressPoolWithContext(ctx context.Context, client *Client, request *DeleteGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmAddressPoolResponse, _err error) {
2348 if dara.BoolValue(client.EnableValidate) == true {
2349 _err = request.Validate()
2350 if _err != nil {
2351 return _result, _err
2352 }
2353 }
2354 query := map[string]interface{}{}
2355 if !dara.IsNil(request.AddrPoolId) {
2356 query["AddrPoolId"] = request.AddrPoolId
2357 }
2358
2359 if !dara.IsNil(request.Lang) {
2360 query["Lang"] = request.Lang
2361 }
2362
2363 req := &openapiutil.OpenApiRequest{
2364 Query: openapiutil.Query(query),
2365 }
2366 params := &openapiutil.Params{
2367 Action: dara.String("DeleteGtmAddressPool"),
2368 Version: dara.String("2015-01-09"),
2369 Protocol: dara.String("HTTPS"),
2370 Pathname: dara.String("/"),
2371 Method: dara.String("POST"),
2372 AuthType: dara.String("AK"),
2373 Style: dara.String("RPC"),
2374 ReqBodyType: dara.String("formData"),
2375 BodyType: dara.String("json"),
2376 }
2377 _result = &DeleteGtmAddressPoolResponse{}
2378 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2379 if _err != nil {
2380 return _result, _err
2381 }
2382 _err = dara.Convert(_body, &_result)
2383 return _result, _err
2384 }
2385
2386 // @param request - DeleteGtmRecoveryPlanRequest
2387 //
2388 // @param runtime - runtime options for this request RuntimeOptions
2389 //
2390 // @return DeleteGtmRecoveryPlanResponse
2391 func DeleteGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *DeleteGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *DeleteGtmRecoveryPlanResponse, _err error) {
2392 if dara.BoolValue(client.EnableValidate) == true {
2393 _err = request.Validate()
2394 if _err != nil {
2395 return _result, _err
2396 }
2397 }
2398 query := map[string]interface{}{}
2399 if !dara.IsNil(request.Lang) {
2400 query["Lang"] = request.Lang
2401 }
2402
2403 if !dara.IsNil(request.RecoveryPlanId) {
2404 query["RecoveryPlanId"] = request.RecoveryPlanId
2405 }
2406
2407 req := &openapiutil.OpenApiRequest{
2408 Query: openapiutil.Query(query),
2409 }
2410 params := &openapiutil.Params{
2411 Action: dara.String("DeleteGtmRecoveryPlan"),
2412 Version: dara.String("2015-01-09"),
2413 Protocol: dara.String("HTTPS"),
2414 Pathname: dara.String("/"),
2415 Method: dara.String("POST"),
2416 AuthType: dara.String("AK"),
2417 Style: dara.String("RPC"),
2418 ReqBodyType: dara.String("formData"),
2419 BodyType: dara.String("json"),
2420 }
2421 _result = &DeleteGtmRecoveryPlanResponse{}
2422 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2423 if _err != nil {
2424 return _result, _err
2425 }
2426 _err = dara.Convert(_body, &_result)
2427 return _result, _err
2428 }
2429
2430 // Summary:
2431 //
2432 // 删除递归解析内置权威解析记录
2433 //
2434 // @param request - DeleteRecursionRecordRequest
2435 //
2436 // @param runtime - runtime options for this request RuntimeOptions
2437 //
2438 // @return DeleteRecursionRecordResponse
2439 func DeleteRecursionRecordWithContext(ctx context.Context, client *Client, request *DeleteRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecursionRecordResponse, _err error) {
2440 if dara.BoolValue(client.EnableValidate) == true {
2441 _err = request.Validate()
2442 if _err != nil {
2443 return _result, _err
2444 }
2445 }
2446 query := map[string]interface{}{}
2447 if !dara.IsNil(request.ClientToken) {
2448 query["ClientToken"] = request.ClientToken
2449 }
2450
2451 if !dara.IsNil(request.RecordId) {
2452 query["RecordId"] = request.RecordId
2453 }
2454
2455 req := &openapiutil.OpenApiRequest{
2456 Query: openapiutil.Query(query),
2457 }
2458 params := &openapiutil.Params{
2459 Action: dara.String("DeleteRecursionRecord"),
2460 Version: dara.String("2015-01-09"),
2461 Protocol: dara.String("HTTPS"),
2462 Pathname: dara.String("/"),
2463 Method: dara.String("POST"),
2464 AuthType: dara.String("AK"),
2465 Style: dara.String("RPC"),
2466 ReqBodyType: dara.String("formData"),
2467 BodyType: dara.String("json"),
2468 }
2469 _result = &DeleteRecursionRecordResponse{}
2470 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2471 if _err != nil {
2472 return _result, _err
2473 }
2474 _err = dara.Convert(_body, &_result)
2475 return _result, _err
2476 }
2477
2478 // Summary:
2479 //
2480 // 删除递归解析内置权威域名zone
2481 //
2482 // @param request - DeleteRecursionZoneRequest
2483 //
2484 // @param runtime - runtime options for this request RuntimeOptions
2485 //
2486 // @return DeleteRecursionZoneResponse
2487 func DeleteRecursionZoneWithContext(ctx context.Context, client *Client, request *DeleteRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecursionZoneResponse, _err error) {
2488 if dara.BoolValue(client.EnableValidate) == true {
2489 _err = request.Validate()
2490 if _err != nil {
2491 return _result, _err
2492 }
2493 }
2494 query := map[string]interface{}{}
2495 if !dara.IsNil(request.ClientToken) {
2496 query["ClientToken"] = request.ClientToken
2497 }
2498
2499 if !dara.IsNil(request.ZoneId) {
2500 query["ZoneId"] = request.ZoneId
2501 }
2502
2503 req := &openapiutil.OpenApiRequest{
2504 Query: openapiutil.Query(query),
2505 }
2506 params := &openapiutil.Params{
2507 Action: dara.String("DeleteRecursionZone"),
2508 Version: dara.String("2015-01-09"),
2509 Protocol: dara.String("HTTPS"),
2510 Pathname: dara.String("/"),
2511 Method: dara.String("POST"),
2512 AuthType: dara.String("AK"),
2513 Style: dara.String("RPC"),
2514 ReqBodyType: dara.String("formData"),
2515 BodyType: dara.String("json"),
2516 }
2517 _result = &DeleteRecursionZoneResponse{}
2518 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2519 if _err != nil {
2520 return _result, _err
2521 }
2522 _err = dara.Convert(_body, &_result)
2523 return _result, _err
2524 }
2525
2526 // Summary:
2527 //
2528 // Deletes the DNS records that are corresponding to a hostname based on the specified parameters.
2529 //
2530 // Description:
2531 //
2532 // If the DNS records to be deleted contain locked DNS records, the locked DNS records will not be deleted.
2533 //
2534 // @param request - DeleteSubDomainRecordsRequest
2535 //
2536 // @param runtime - runtime options for this request RuntimeOptions
2537 //
2538 // @return DeleteSubDomainRecordsResponse
2539 func DeleteSubDomainRecordsWithContext(ctx context.Context, client *Client, request *DeleteSubDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DeleteSubDomainRecordsResponse, _err error) {
2540 if dara.BoolValue(client.EnableValidate) == true {
2541 _err = request.Validate()
2542 if _err != nil {
2543 return _result, _err
2544 }
2545 }
2546 query := map[string]interface{}{}
2547 if !dara.IsNil(request.DomainName) {
2548 query["DomainName"] = request.DomainName
2549 }
2550
2551 if !dara.IsNil(request.Lang) {
2552 query["Lang"] = request.Lang
2553 }
2554
2555 if !dara.IsNil(request.RR) {
2556 query["RR"] = request.RR
2557 }
2558
2559 if !dara.IsNil(request.Type) {
2560 query["Type"] = request.Type
2561 }
2562
2563 if !dara.IsNil(request.UserClientIp) {
2564 query["UserClientIp"] = request.UserClientIp
2565 }
2566
2567 req := &openapiutil.OpenApiRequest{
2568 Query: openapiutil.Query(query),
2569 }
2570 params := &openapiutil.Params{
2571 Action: dara.String("DeleteSubDomainRecords"),
2572 Version: dara.String("2015-01-09"),
2573 Protocol: dara.String("HTTPS"),
2574 Pathname: dara.String("/"),
2575 Method: dara.String("POST"),
2576 AuthType: dara.String("AK"),
2577 Style: dara.String("RPC"),
2578 ReqBodyType: dara.String("formData"),
2579 BodyType: dara.String("json"),
2580 }
2581 _result = &DeleteSubDomainRecordsResponse{}
2582 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2583 if _err != nil {
2584 return _result, _err
2585 }
2586 _err = dara.Convert(_body, &_result)
2587 return _result, _err
2588 }
2589
2590 // Summary:
2591 //
2592 // 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.
2593 //
2594 // @param request - DescribeBatchResultCountRequest
2595 //
2596 // @param runtime - runtime options for this request RuntimeOptions
2597 //
2598 // @return DescribeBatchResultCountResponse
2599 func DescribeBatchResultCountWithContext(ctx context.Context, client *Client, request *DescribeBatchResultCountRequest, runtime *dara.RuntimeOptions) (_result *DescribeBatchResultCountResponse, _err error) {
2600 if dara.BoolValue(client.EnableValidate) == true {
2601 _err = request.Validate()
2602 if _err != nil {
2603 return _result, _err
2604 }
2605 }
2606 query := map[string]interface{}{}
2607 if !dara.IsNil(request.BatchType) {
2608 query["BatchType"] = request.BatchType
2609 }
2610
2611 if !dara.IsNil(request.Lang) {
2612 query["Lang"] = request.Lang
2613 }
2614
2615 if !dara.IsNil(request.TaskId) {
2616 query["TaskId"] = request.TaskId
2617 }
2618
2619 req := &openapiutil.OpenApiRequest{
2620 Query: openapiutil.Query(query),
2621 }
2622 params := &openapiutil.Params{
2623 Action: dara.String("DescribeBatchResultCount"),
2624 Version: dara.String("2015-01-09"),
2625 Protocol: dara.String("HTTPS"),
2626 Pathname: dara.String("/"),
2627 Method: dara.String("POST"),
2628 AuthType: dara.String("AK"),
2629 Style: dara.String("RPC"),
2630 ReqBodyType: dara.String("formData"),
2631 BodyType: dara.String("json"),
2632 }
2633 _result = &DescribeBatchResultCountResponse{}
2634 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2635 if _err != nil {
2636 return _result, _err
2637 }
2638 _err = dara.Convert(_body, &_result)
2639 return _result, _err
2640 }
2641
2642 // Summary:
2643 //
2644 // Queries the detailed results of a batch operation task.
2645 //
2646 // Description:
2647 //
2648 // Before you call this operation, make sure that the batch operation task is complete.
2649 //
2650 // @param request - DescribeBatchResultDetailRequest
2651 //
2652 // @param runtime - runtime options for this request RuntimeOptions
2653 //
2654 // @return DescribeBatchResultDetailResponse
2655 func DescribeBatchResultDetailWithContext(ctx context.Context, client *Client, request *DescribeBatchResultDetailRequest, runtime *dara.RuntimeOptions) (_result *DescribeBatchResultDetailResponse, _err error) {
2656 if dara.BoolValue(client.EnableValidate) == true {
2657 _err = request.Validate()
2658 if _err != nil {
2659 return _result, _err
2660 }
2661 }
2662 query := map[string]interface{}{}
2663 if !dara.IsNil(request.BatchType) {
2664 query["BatchType"] = request.BatchType
2665 }
2666
2667 if !dara.IsNil(request.Lang) {
2668 query["Lang"] = request.Lang
2669 }
2670
2671 if !dara.IsNil(request.PageNumber) {
2672 query["PageNumber"] = request.PageNumber
2673 }
2674
2675 if !dara.IsNil(request.PageSize) {
2676 query["PageSize"] = request.PageSize
2677 }
2678
2679 if !dara.IsNil(request.Status) {
2680 query["Status"] = request.Status
2681 }
2682
2683 if !dara.IsNil(request.TaskId) {
2684 query["TaskId"] = request.TaskId
2685 }
2686
2687 req := &openapiutil.OpenApiRequest{
2688 Query: openapiutil.Query(query),
2689 }
2690 params := &openapiutil.Params{
2691 Action: dara.String("DescribeBatchResultDetail"),
2692 Version: dara.String("2015-01-09"),
2693 Protocol: dara.String("HTTPS"),
2694 Pathname: dara.String("/"),
2695 Method: dara.String("POST"),
2696 AuthType: dara.String("AK"),
2697 Style: dara.String("RPC"),
2698 ReqBodyType: dara.String("formData"),
2699 BodyType: dara.String("json"),
2700 }
2701 _result = &DescribeBatchResultDetailResponse{}
2702 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2703 if _err != nil {
2704 return _result, _err
2705 }
2706 _err = dara.Convert(_body, &_result)
2707 return _result, _err
2708 }
2709
2710 // Summary:
2711 //
2712 // Queries the configurations of an address.
2713 //
2714 // @param request - DescribeCloudGtmAddressRequest
2715 //
2716 // @param runtime - runtime options for this request RuntimeOptions
2717 //
2718 // @return DescribeCloudGtmAddressResponse
2719 func DescribeCloudGtmAddressWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressResponse, _err error) {
2720 if dara.BoolValue(client.EnableValidate) == true {
2721 _err = request.Validate()
2722 if _err != nil {
2723 return _result, _err
2724 }
2725 }
2726 query := map[string]interface{}{}
2727 if !dara.IsNil(request.AcceptLanguage) {
2728 query["AcceptLanguage"] = request.AcceptLanguage
2729 }
2730
2731 if !dara.IsNil(request.AddressId) {
2732 query["AddressId"] = request.AddressId
2733 }
2734
2735 if !dara.IsNil(request.ClientToken) {
2736 query["ClientToken"] = request.ClientToken
2737 }
2738
2739 req := &openapiutil.OpenApiRequest{
2740 Query: openapiutil.Query(query),
2741 }
2742 params := &openapiutil.Params{
2743 Action: dara.String("DescribeCloudGtmAddress"),
2744 Version: dara.String("2015-01-09"),
2745 Protocol: dara.String("HTTPS"),
2746 Pathname: dara.String("/"),
2747 Method: dara.String("POST"),
2748 AuthType: dara.String("AK"),
2749 Style: dara.String("RPC"),
2750 ReqBodyType: dara.String("formData"),
2751 BodyType: dara.String("json"),
2752 }
2753 _result = &DescribeCloudGtmAddressResponse{}
2754 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2755 if _err != nil {
2756 return _result, _err
2757 }
2758 _err = dara.Convert(_body, &_result)
2759 return _result, _err
2760 }
2761
2762 // Summary:
2763 //
2764 // Queries the configurations of an address pool.
2765 //
2766 // @param request - DescribeCloudGtmAddressPoolRequest
2767 //
2768 // @param runtime - runtime options for this request RuntimeOptions
2769 //
2770 // @return DescribeCloudGtmAddressPoolResponse
2771 func DescribeCloudGtmAddressPoolWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressPoolResponse, _err error) {
2772 if dara.BoolValue(client.EnableValidate) == true {
2773 _err = request.Validate()
2774 if _err != nil {
2775 return _result, _err
2776 }
2777 }
2778 query := map[string]interface{}{}
2779 if !dara.IsNil(request.AcceptLanguage) {
2780 query["AcceptLanguage"] = request.AcceptLanguage
2781 }
2782
2783 if !dara.IsNil(request.AddressPoolId) {
2784 query["AddressPoolId"] = request.AddressPoolId
2785 }
2786
2787 if !dara.IsNil(request.ClientToken) {
2788 query["ClientToken"] = request.ClientToken
2789 }
2790
2791 req := &openapiutil.OpenApiRequest{
2792 Query: openapiutil.Query(query),
2793 }
2794 params := &openapiutil.Params{
2795 Action: dara.String("DescribeCloudGtmAddressPool"),
2796 Version: dara.String("2015-01-09"),
2797 Protocol: dara.String("HTTPS"),
2798 Pathname: dara.String("/"),
2799 Method: dara.String("POST"),
2800 AuthType: dara.String("AK"),
2801 Style: dara.String("RPC"),
2802 ReqBodyType: dara.String("formData"),
2803 BodyType: dara.String("json"),
2804 }
2805 _result = &DescribeCloudGtmAddressPoolResponse{}
2806 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2807 if _err != nil {
2808 return _result, _err
2809 }
2810 _err = dara.Convert(_body, &_result)
2811 return _result, _err
2812 }
2813
2814 // Summary:
2815 //
2816 // Queries the information about the access domain names that reference an address pool.
2817 //
2818 // @param request - DescribeCloudGtmAddressPoolReferenceRequest
2819 //
2820 // @param runtime - runtime options for this request RuntimeOptions
2821 //
2822 // @return DescribeCloudGtmAddressPoolReferenceResponse
2823 func DescribeCloudGtmAddressPoolReferenceWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmAddressPoolReferenceRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressPoolReferenceResponse, _err error) {
2824 if dara.BoolValue(client.EnableValidate) == true {
2825 _err = request.Validate()
2826 if _err != nil {
2827 return _result, _err
2828 }
2829 }
2830 query := map[string]interface{}{}
2831 if !dara.IsNil(request.AcceptLanguage) {
2832 query["AcceptLanguage"] = request.AcceptLanguage
2833 }
2834
2835 if !dara.IsNil(request.AddressPoolId) {
2836 query["AddressPoolId"] = request.AddressPoolId
2837 }
2838
2839 if !dara.IsNil(request.ClientToken) {
2840 query["ClientToken"] = request.ClientToken
2841 }
2842
2843 req := &openapiutil.OpenApiRequest{
2844 Query: openapiutil.Query(query),
2845 }
2846 params := &openapiutil.Params{
2847 Action: dara.String("DescribeCloudGtmAddressPoolReference"),
2848 Version: dara.String("2015-01-09"),
2849 Protocol: dara.String("HTTPS"),
2850 Pathname: dara.String("/"),
2851 Method: dara.String("POST"),
2852 AuthType: dara.String("AK"),
2853 Style: dara.String("RPC"),
2854 ReqBodyType: dara.String("formData"),
2855 BodyType: dara.String("json"),
2856 }
2857 _result = &DescribeCloudGtmAddressPoolReferenceResponse{}
2858 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2859 if _err != nil {
2860 return _result, _err
2861 }
2862 _err = dara.Convert(_body, &_result)
2863 return _result, _err
2864 }
2865
2866 // Summary:
2867 //
2868 // Queries the information about the address pools and Global Traffic Manager (GTM) 3.0 instances that reference an address.
2869 //
2870 // @param request - DescribeCloudGtmAddressReferenceRequest
2871 //
2872 // @param runtime - runtime options for this request RuntimeOptions
2873 //
2874 // @return DescribeCloudGtmAddressReferenceResponse
2875 func DescribeCloudGtmAddressReferenceWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmAddressReferenceRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmAddressReferenceResponse, _err error) {
2876 if dara.BoolValue(client.EnableValidate) == true {
2877 _err = request.Validate()
2878 if _err != nil {
2879 return _result, _err
2880 }
2881 }
2882 query := map[string]interface{}{}
2883 if !dara.IsNil(request.AcceptLanguage) {
2884 query["AcceptLanguage"] = request.AcceptLanguage
2885 }
2886
2887 if !dara.IsNil(request.AddressId) {
2888 query["AddressId"] = request.AddressId
2889 }
2890
2891 if !dara.IsNil(request.ClientToken) {
2892 query["ClientToken"] = request.ClientToken
2893 }
2894
2895 req := &openapiutil.OpenApiRequest{
2896 Query: openapiutil.Query(query),
2897 }
2898 params := &openapiutil.Params{
2899 Action: dara.String("DescribeCloudGtmAddressReference"),
2900 Version: dara.String("2015-01-09"),
2901 Protocol: dara.String("HTTPS"),
2902 Pathname: dara.String("/"),
2903 Method: dara.String("POST"),
2904 AuthType: dara.String("AK"),
2905 Style: dara.String("RPC"),
2906 ReqBodyType: dara.String("formData"),
2907 BodyType: dara.String("json"),
2908 }
2909 _result = &DescribeCloudGtmAddressReferenceResponse{}
2910 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2911 if _err != nil {
2912 return _result, _err
2913 }
2914 _err = dara.Convert(_body, &_result)
2915 return _result, _err
2916 }
2917
2918 // @param request - DescribeCloudGtmGlobalAlertRequest
2919 //
2920 // @param runtime - runtime options for this request RuntimeOptions
2921 //
2922 // @return DescribeCloudGtmGlobalAlertResponse
2923 func DescribeCloudGtmGlobalAlertWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmGlobalAlertRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmGlobalAlertResponse, _err error) {
2924 if dara.BoolValue(client.EnableValidate) == true {
2925 _err = request.Validate()
2926 if _err != nil {
2927 return _result, _err
2928 }
2929 }
2930 query := map[string]interface{}{}
2931 if !dara.IsNil(request.AcceptLanguage) {
2932 query["AcceptLanguage"] = request.AcceptLanguage
2933 }
2934
2935 if !dara.IsNil(request.ClientToken) {
2936 query["ClientToken"] = request.ClientToken
2937 }
2938
2939 req := &openapiutil.OpenApiRequest{
2940 Query: openapiutil.Query(query),
2941 }
2942 params := &openapiutil.Params{
2943 Action: dara.String("DescribeCloudGtmGlobalAlert"),
2944 Version: dara.String("2015-01-09"),
2945 Protocol: dara.String("HTTPS"),
2946 Pathname: dara.String("/"),
2947 Method: dara.String("POST"),
2948 AuthType: dara.String("AK"),
2949 Style: dara.String("RPC"),
2950 ReqBodyType: dara.String("formData"),
2951 BodyType: dara.String("json"),
2952 }
2953 _result = &DescribeCloudGtmGlobalAlertResponse{}
2954 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2955 if _err != nil {
2956 return _result, _err
2957 }
2958 _err = dara.Convert(_body, &_result)
2959 return _result, _err
2960 }
2961
2962 // @param request - DescribeCloudGtmInstanceConfigAlertRequest
2963 //
2964 // @param runtime - runtime options for this request RuntimeOptions
2965 //
2966 // @return DescribeCloudGtmInstanceConfigAlertResponse
2967 func DescribeCloudGtmInstanceConfigAlertWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmInstanceConfigAlertRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmInstanceConfigAlertResponse, _err error) {
2968 if dara.BoolValue(client.EnableValidate) == true {
2969 _err = request.Validate()
2970 if _err != nil {
2971 return _result, _err
2972 }
2973 }
2974 query := map[string]interface{}{}
2975 if !dara.IsNil(request.AcceptLanguage) {
2976 query["AcceptLanguage"] = request.AcceptLanguage
2977 }
2978
2979 if !dara.IsNil(request.ClientToken) {
2980 query["ClientToken"] = request.ClientToken
2981 }
2982
2983 if !dara.IsNil(request.ConfigId) {
2984 query["ConfigId"] = request.ConfigId
2985 }
2986
2987 if !dara.IsNil(request.InstanceId) {
2988 query["InstanceId"] = request.InstanceId
2989 }
2990
2991 req := &openapiutil.OpenApiRequest{
2992 Query: openapiutil.Query(query),
2993 }
2994 params := &openapiutil.Params{
2995 Action: dara.String("DescribeCloudGtmInstanceConfigAlert"),
2996 Version: dara.String("2015-01-09"),
2997 Protocol: dara.String("HTTPS"),
2998 Pathname: dara.String("/"),
2999 Method: dara.String("POST"),
3000 AuthType: dara.String("AK"),
3001 Style: dara.String("RPC"),
3002 ReqBodyType: dara.String("formData"),
3003 BodyType: dara.String("json"),
3004 }
3005 _result = &DescribeCloudGtmInstanceConfigAlertResponse{}
3006 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3007 if _err != nil {
3008 return _result, _err
3009 }
3010 _err = dara.Convert(_body, &_result)
3011 return _result, _err
3012 }
3013
3014 // Summary:
3015 //
3016 // Queries the complete configuration information about a Global Traffic Manager (GTM) instance.
3017 //
3018 // @param request - DescribeCloudGtmInstanceConfigFullInfoRequest
3019 //
3020 // @param runtime - runtime options for this request RuntimeOptions
3021 //
3022 // @return DescribeCloudGtmInstanceConfigFullInfoResponse
3023 func DescribeCloudGtmInstanceConfigFullInfoWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmInstanceConfigFullInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmInstanceConfigFullInfoResponse, _err error) {
3024 if dara.BoolValue(client.EnableValidate) == true {
3025 _err = request.Validate()
3026 if _err != nil {
3027 return _result, _err
3028 }
3029 }
3030 query := map[string]interface{}{}
3031 if !dara.IsNil(request.AcceptLanguage) {
3032 query["AcceptLanguage"] = request.AcceptLanguage
3033 }
3034
3035 if !dara.IsNil(request.ClientToken) {
3036 query["ClientToken"] = request.ClientToken
3037 }
3038
3039 if !dara.IsNil(request.ConfigId) {
3040 query["ConfigId"] = request.ConfigId
3041 }
3042
3043 if !dara.IsNil(request.InstanceId) {
3044 query["InstanceId"] = request.InstanceId
3045 }
3046
3047 req := &openapiutil.OpenApiRequest{
3048 Query: openapiutil.Query(query),
3049 }
3050 params := &openapiutil.Params{
3051 Action: dara.String("DescribeCloudGtmInstanceConfigFullInfo"),
3052 Version: dara.String("2015-01-09"),
3053 Protocol: dara.String("HTTPS"),
3054 Pathname: dara.String("/"),
3055 Method: dara.String("POST"),
3056 AuthType: dara.String("AK"),
3057 Style: dara.String("RPC"),
3058 ReqBodyType: dara.String("formData"),
3059 BodyType: dara.String("json"),
3060 }
3061 _result = &DescribeCloudGtmInstanceConfigFullInfoResponse{}
3062 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3063 if _err != nil {
3064 return _result, _err
3065 }
3066 _err = dara.Convert(_body, &_result)
3067 return _result, _err
3068 }
3069
3070 // Summary:
3071 //
3072 // Queries the configurations of a health check template.
3073 //
3074 // @param request - DescribeCloudGtmMonitorTemplateRequest
3075 //
3076 // @param runtime - runtime options for this request RuntimeOptions
3077 //
3078 // @return DescribeCloudGtmMonitorTemplateResponse
3079 func DescribeCloudGtmMonitorTemplateWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmMonitorTemplateResponse, _err error) {
3080 if dara.BoolValue(client.EnableValidate) == true {
3081 _err = request.Validate()
3082 if _err != nil {
3083 return _result, _err
3084 }
3085 }
3086 query := map[string]interface{}{}
3087 if !dara.IsNil(request.AcceptLanguage) {
3088 query["AcceptLanguage"] = request.AcceptLanguage
3089 }
3090
3091 if !dara.IsNil(request.TemplateId) {
3092 query["TemplateId"] = request.TemplateId
3093 }
3094
3095 req := &openapiutil.OpenApiRequest{
3096 Query: openapiutil.Query(query),
3097 }
3098 params := &openapiutil.Params{
3099 Action: dara.String("DescribeCloudGtmMonitorTemplate"),
3100 Version: dara.String("2015-01-09"),
3101 Protocol: dara.String("HTTPS"),
3102 Pathname: dara.String("/"),
3103 Method: dara.String("POST"),
3104 AuthType: dara.String("AK"),
3105 Style: dara.String("RPC"),
3106 ReqBodyType: dara.String("formData"),
3107 BodyType: dara.String("json"),
3108 }
3109 _result = &DescribeCloudGtmMonitorTemplateResponse{}
3110 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3111 if _err != nil {
3112 return _result, _err
3113 }
3114 _err = dara.Convert(_body, &_result)
3115 return _result, _err
3116 }
3117
3118 // @param request - DescribeCloudGtmSummaryRequest
3119 //
3120 // @param runtime - runtime options for this request RuntimeOptions
3121 //
3122 // @return DescribeCloudGtmSummaryResponse
3123 func DescribeCloudGtmSummaryWithContext(ctx context.Context, client *Client, request *DescribeCloudGtmSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeCloudGtmSummaryResponse, _err error) {
3124 if dara.BoolValue(client.EnableValidate) == true {
3125 _err = request.Validate()
3126 if _err != nil {
3127 return _result, _err
3128 }
3129 }
3130 query := map[string]interface{}{}
3131 if !dara.IsNil(request.AcceptLanguage) {
3132 query["AcceptLanguage"] = request.AcceptLanguage
3133 }
3134
3135 req := &openapiutil.OpenApiRequest{
3136 Query: openapiutil.Query(query),
3137 }
3138 params := &openapiutil.Params{
3139 Action: dara.String("DescribeCloudGtmSummary"),
3140 Version: dara.String("2015-01-09"),
3141 Protocol: dara.String("HTTPS"),
3142 Pathname: dara.String("/"),
3143 Method: dara.String("POST"),
3144 AuthType: dara.String("AK"),
3145 Style: dara.String("RPC"),
3146 ReqBodyType: dara.String("formData"),
3147 BodyType: dara.String("json"),
3148 }
3149 _result = &DescribeCloudGtmSummaryResponse{}
3150 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3151 if _err != nil {
3152 return _result, _err
3153 }
3154 _err = dara.Convert(_body, &_result)
3155 return _result, _err
3156 }
3157
3158 // Summary:
3159 //
3160 // Queries the details of a custom line by its unique ID.
3161 //
3162 // @param request - DescribeCustomLineRequest
3163 //
3164 // @param runtime - runtime options for this request RuntimeOptions
3165 //
3166 // @return DescribeCustomLineResponse
3167 func DescribeCustomLineWithContext(ctx context.Context, client *Client, request *DescribeCustomLineRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomLineResponse, _err error) {
3168 if dara.BoolValue(client.EnableValidate) == true {
3169 _err = request.Validate()
3170 if _err != nil {
3171 return _result, _err
3172 }
3173 }
3174 query := map[string]interface{}{}
3175 if !dara.IsNil(request.Lang) {
3176 query["Lang"] = request.Lang
3177 }
3178
3179 if !dara.IsNil(request.LineId) {
3180 query["LineId"] = request.LineId
3181 }
3182
3183 req := &openapiutil.OpenApiRequest{
3184 Query: openapiutil.Query(query),
3185 }
3186 params := &openapiutil.Params{
3187 Action: dara.String("DescribeCustomLine"),
3188 Version: dara.String("2015-01-09"),
3189 Protocol: dara.String("HTTPS"),
3190 Pathname: dara.String("/"),
3191 Method: dara.String("POST"),
3192 AuthType: dara.String("AK"),
3193 Style: dara.String("RPC"),
3194 ReqBodyType: dara.String("formData"),
3195 BodyType: dara.String("json"),
3196 }
3197 _result = &DescribeCustomLineResponse{}
3198 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3199 if _err != nil {
3200 return _result, _err
3201 }
3202 _err = dara.Convert(_body, &_result)
3203 return _result, _err
3204 }
3205
3206 // Summary:
3207 //
3208 // Queries custom lines by domain name.
3209 //
3210 // @param request - DescribeCustomLinesRequest
3211 //
3212 // @param runtime - runtime options for this request RuntimeOptions
3213 //
3214 // @return DescribeCustomLinesResponse
3215 func DescribeCustomLinesWithContext(ctx context.Context, client *Client, request *DescribeCustomLinesRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomLinesResponse, _err error) {
3216 if dara.BoolValue(client.EnableValidate) == true {
3217 _err = request.Validate()
3218 if _err != nil {
3219 return _result, _err
3220 }
3221 }
3222 query := map[string]interface{}{}
3223 if !dara.IsNil(request.DomainName) {
3224 query["DomainName"] = request.DomainName
3225 }
3226
3227 if !dara.IsNil(request.Lang) {
3228 query["Lang"] = request.Lang
3229 }
3230
3231 if !dara.IsNil(request.PageNumber) {
3232 query["PageNumber"] = request.PageNumber
3233 }
3234
3235 if !dara.IsNil(request.PageSize) {
3236 query["PageSize"] = request.PageSize
3237 }
3238
3239 req := &openapiutil.OpenApiRequest{
3240 Query: openapiutil.Query(query),
3241 }
3242 params := &openapiutil.Params{
3243 Action: dara.String("DescribeCustomLines"),
3244 Version: dara.String("2015-01-09"),
3245 Protocol: dara.String("HTTPS"),
3246 Pathname: dara.String("/"),
3247 Method: dara.String("POST"),
3248 AuthType: dara.String("AK"),
3249 Style: dara.String("RPC"),
3250 ReqBodyType: dara.String("formData"),
3251 BodyType: dara.String("json"),
3252 }
3253 _result = &DescribeCustomLinesResponse{}
3254 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3255 if _err != nil {
3256 return _result, _err
3257 }
3258 _err = dara.Convert(_body, &_result)
3259 return _result, _err
3260 }
3261
3262 // Summary:
3263 //
3264 // Queries the subdomains for which weighted round-robin is enabled based on the specified parameters.
3265 //
3266 // @param request - DescribeDNSSLBSubDomainsRequest
3267 //
3268 // @param runtime - runtime options for this request RuntimeOptions
3269 //
3270 // @return DescribeDNSSLBSubDomainsResponse
3271 func DescribeDNSSLBSubDomainsWithContext(ctx context.Context, client *Client, request *DescribeDNSSLBSubDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDNSSLBSubDomainsResponse, _err error) {
3272 if dara.BoolValue(client.EnableValidate) == true {
3273 _err = request.Validate()
3274 if _err != nil {
3275 return _result, _err
3276 }
3277 }
3278 query := map[string]interface{}{}
3279 if !dara.IsNil(request.DomainName) {
3280 query["DomainName"] = request.DomainName
3281 }
3282
3283 if !dara.IsNil(request.Lang) {
3284 query["Lang"] = request.Lang
3285 }
3286
3287 if !dara.IsNil(request.PageNumber) {
3288 query["PageNumber"] = request.PageNumber
3289 }
3290
3291 if !dara.IsNil(request.PageSize) {
3292 query["PageSize"] = request.PageSize
3293 }
3294
3295 if !dara.IsNil(request.Rr) {
3296 query["Rr"] = request.Rr
3297 }
3298
3299 if !dara.IsNil(request.UserClientIp) {
3300 query["UserClientIp"] = request.UserClientIp
3301 }
3302
3303 req := &openapiutil.OpenApiRequest{
3304 Query: openapiutil.Query(query),
3305 }
3306 params := &openapiutil.Params{
3307 Action: dara.String("DescribeDNSSLBSubDomains"),
3308 Version: dara.String("2015-01-09"),
3309 Protocol: dara.String("HTTPS"),
3310 Pathname: dara.String("/"),
3311 Method: dara.String("POST"),
3312 AuthType: dara.String("AK"),
3313 Style: dara.String("RPC"),
3314 ReqBodyType: dara.String("formData"),
3315 BodyType: dara.String("json"),
3316 }
3317 _result = &DescribeDNSSLBSubDomainsResponse{}
3318 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3319 if _err != nil {
3320 return _result, _err
3321 }
3322 _err = dara.Convert(_body, &_result)
3323 return _result, _err
3324 }
3325
3326 // Summary:
3327 //
3328 // 查询代理域名
3329 //
3330 // @param request - DescribeDnsCacheDomainsRequest
3331 //
3332 // @param runtime - runtime options for this request RuntimeOptions
3333 //
3334 // @return DescribeDnsCacheDomainsResponse
3335 func DescribeDnsCacheDomainsWithContext(ctx context.Context, client *Client, request *DescribeDnsCacheDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsCacheDomainsResponse, _err error) {
3336 if dara.BoolValue(client.EnableValidate) == true {
3337 _err = request.Validate()
3338 if _err != nil {
3339 return _result, _err
3340 }
3341 }
3342 query := map[string]interface{}{}
3343 if !dara.IsNil(request.Keyword) {
3344 query["Keyword"] = request.Keyword
3345 }
3346
3347 if !dara.IsNil(request.Lang) {
3348 query["Lang"] = request.Lang
3349 }
3350
3351 if !dara.IsNil(request.PageNumber) {
3352 query["PageNumber"] = request.PageNumber
3353 }
3354
3355 if !dara.IsNil(request.PageSize) {
3356 query["PageSize"] = request.PageSize
3357 }
3358
3359 req := &openapiutil.OpenApiRequest{
3360 Query: openapiutil.Query(query),
3361 }
3362 params := &openapiutil.Params{
3363 Action: dara.String("DescribeDnsCacheDomains"),
3364 Version: dara.String("2015-01-09"),
3365 Protocol: dara.String("HTTPS"),
3366 Pathname: dara.String("/"),
3367 Method: dara.String("POST"),
3368 AuthType: dara.String("AK"),
3369 Style: dara.String("RPC"),
3370 ReqBodyType: dara.String("formData"),
3371 BodyType: dara.String("json"),
3372 }
3373 _result = &DescribeDnsCacheDomainsResponse{}
3374 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3375 if _err != nil {
3376 return _result, _err
3377 }
3378 _err = dara.Convert(_body, &_result)
3379 return _result, _err
3380 }
3381
3382 // Summary:
3383 //
3384 // Queries access policies of a Global Traffic Manager (GTM) instance.
3385 //
3386 // @param request - DescribeDnsGtmAccessStrategiesRequest
3387 //
3388 // @param runtime - runtime options for this request RuntimeOptions
3389 //
3390 // @return DescribeDnsGtmAccessStrategiesResponse
3391 func DescribeDnsGtmAccessStrategiesWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAccessStrategiesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategiesResponse, _err error) {
3392 if dara.BoolValue(client.EnableValidate) == true {
3393 _err = request.Validate()
3394 if _err != nil {
3395 return _result, _err
3396 }
3397 }
3398 query := map[string]interface{}{}
3399 if !dara.IsNil(request.InstanceId) {
3400 query["InstanceId"] = request.InstanceId
3401 }
3402
3403 if !dara.IsNil(request.Lang) {
3404 query["Lang"] = request.Lang
3405 }
3406
3407 if !dara.IsNil(request.PageNumber) {
3408 query["PageNumber"] = request.PageNumber
3409 }
3410
3411 if !dara.IsNil(request.PageSize) {
3412 query["PageSize"] = request.PageSize
3413 }
3414
3415 if !dara.IsNil(request.StrategyMode) {
3416 query["StrategyMode"] = request.StrategyMode
3417 }
3418
3419 req := &openapiutil.OpenApiRequest{
3420 Query: openapiutil.Query(query),
3421 }
3422 params := &openapiutil.Params{
3423 Action: dara.String("DescribeDnsGtmAccessStrategies"),
3424 Version: dara.String("2015-01-09"),
3425 Protocol: dara.String("HTTPS"),
3426 Pathname: dara.String("/"),
3427 Method: dara.String("POST"),
3428 AuthType: dara.String("AK"),
3429 Style: dara.String("RPC"),
3430 ReqBodyType: dara.String("formData"),
3431 BodyType: dara.String("json"),
3432 }
3433 _result = &DescribeDnsGtmAccessStrategiesResponse{}
3434 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3435 if _err != nil {
3436 return _result, _err
3437 }
3438 _err = dara.Convert(_body, &_result)
3439 return _result, _err
3440 }
3441
3442 // Summary:
3443 //
3444 // Queries detailed information about an access policy of a Global Traffic Manager (GTM) instance.
3445 //
3446 // @param request - DescribeDnsGtmAccessStrategyRequest
3447 //
3448 // @param runtime - runtime options for this request RuntimeOptions
3449 //
3450 // @return DescribeDnsGtmAccessStrategyResponse
3451 func DescribeDnsGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategyResponse, _err error) {
3452 if dara.BoolValue(client.EnableValidate) == true {
3453 _err = request.Validate()
3454 if _err != nil {
3455 return _result, _err
3456 }
3457 }
3458 query := map[string]interface{}{}
3459 if !dara.IsNil(request.Lang) {
3460 query["Lang"] = request.Lang
3461 }
3462
3463 if !dara.IsNil(request.StrategyId) {
3464 query["StrategyId"] = request.StrategyId
3465 }
3466
3467 req := &openapiutil.OpenApiRequest{
3468 Query: openapiutil.Query(query),
3469 }
3470 params := &openapiutil.Params{
3471 Action: dara.String("DescribeDnsGtmAccessStrategy"),
3472 Version: dara.String("2015-01-09"),
3473 Protocol: dara.String("HTTPS"),
3474 Pathname: dara.String("/"),
3475 Method: dara.String("POST"),
3476 AuthType: dara.String("AK"),
3477 Style: dara.String("RPC"),
3478 ReqBodyType: dara.String("formData"),
3479 BodyType: dara.String("json"),
3480 }
3481 _result = &DescribeDnsGtmAccessStrategyResponse{}
3482 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3483 if _err != nil {
3484 return _result, _err
3485 }
3486 _err = dara.Convert(_body, &_result)
3487 return _result, _err
3488 }
3489
3490 // Summary:
3491 //
3492 // Queries the available configurations of an access policy of a Global Traffic Manager (GTM) instance.
3493 //
3494 // @param request - DescribeDnsGtmAccessStrategyAvailableConfigRequest
3495 //
3496 // @param runtime - runtime options for this request RuntimeOptions
3497 //
3498 // @return DescribeDnsGtmAccessStrategyAvailableConfigResponse
3499 func DescribeDnsGtmAccessStrategyAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAccessStrategyAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAccessStrategyAvailableConfigResponse, _err error) {
3500 if dara.BoolValue(client.EnableValidate) == true {
3501 _err = request.Validate()
3502 if _err != nil {
3503 return _result, _err
3504 }
3505 }
3506 query := map[string]interface{}{}
3507 if !dara.IsNil(request.InstanceId) {
3508 query["InstanceId"] = request.InstanceId
3509 }
3510
3511 if !dara.IsNil(request.Lang) {
3512 query["Lang"] = request.Lang
3513 }
3514
3515 if !dara.IsNil(request.StrategyMode) {
3516 query["StrategyMode"] = request.StrategyMode
3517 }
3518
3519 req := &openapiutil.OpenApiRequest{
3520 Query: openapiutil.Query(query),
3521 }
3522 params := &openapiutil.Params{
3523 Action: dara.String("DescribeDnsGtmAccessStrategyAvailableConfig"),
3524 Version: dara.String("2015-01-09"),
3525 Protocol: dara.String("HTTPS"),
3526 Pathname: dara.String("/"),
3527 Method: dara.String("POST"),
3528 AuthType: dara.String("AK"),
3529 Style: dara.String("RPC"),
3530 ReqBodyType: dara.String("formData"),
3531 BodyType: dara.String("json"),
3532 }
3533 _result = &DescribeDnsGtmAccessStrategyAvailableConfigResponse{}
3534 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3535 if _err != nil {
3536 return _result, _err
3537 }
3538 _err = dara.Convert(_body, &_result)
3539 return _result, _err
3540 }
3541
3542 // Summary:
3543 //
3544 // Queries the source regions of addresses.
3545 //
3546 // @param request - DescribeDnsGtmAddrAttributeInfoRequest
3547 //
3548 // @param runtime - runtime options for this request RuntimeOptions
3549 //
3550 // @return DescribeDnsGtmAddrAttributeInfoResponse
3551 func DescribeDnsGtmAddrAttributeInfoWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAddrAttributeInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAddrAttributeInfoResponse, _err error) {
3552 if dara.BoolValue(client.EnableValidate) == true {
3553 _err = request.Validate()
3554 if _err != nil {
3555 return _result, _err
3556 }
3557 }
3558 query := map[string]interface{}{}
3559 if !dara.IsNil(request.Addrs) {
3560 query["Addrs"] = request.Addrs
3561 }
3562
3563 if !dara.IsNil(request.Lang) {
3564 query["Lang"] = request.Lang
3565 }
3566
3567 if !dara.IsNil(request.Type) {
3568 query["Type"] = request.Type
3569 }
3570
3571 req := &openapiutil.OpenApiRequest{
3572 Query: openapiutil.Query(query),
3573 }
3574 params := &openapiutil.Params{
3575 Action: dara.String("DescribeDnsGtmAddrAttributeInfo"),
3576 Version: dara.String("2015-01-09"),
3577 Protocol: dara.String("HTTPS"),
3578 Pathname: dara.String("/"),
3579 Method: dara.String("POST"),
3580 AuthType: dara.String("AK"),
3581 Style: dara.String("RPC"),
3582 ReqBodyType: dara.String("formData"),
3583 BodyType: dara.String("json"),
3584 }
3585 _result = &DescribeDnsGtmAddrAttributeInfoResponse{}
3586 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3587 if _err != nil {
3588 return _result, _err
3589 }
3590 _err = dara.Convert(_body, &_result)
3591 return _result, _err
3592 }
3593
3594 // Summary:
3595 //
3596 // Queries the available configurations of an address pool of a Global Traffic Manager (GTM) instance.
3597 //
3598 // @param request - DescribeDnsGtmAddressPoolAvailableConfigRequest
3599 //
3600 // @param runtime - runtime options for this request RuntimeOptions
3601 //
3602 // @return DescribeDnsGtmAddressPoolAvailableConfigResponse
3603 func DescribeDnsGtmAddressPoolAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAddressPoolAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAddressPoolAvailableConfigResponse, _err error) {
3604 if dara.BoolValue(client.EnableValidate) == true {
3605 _err = request.Validate()
3606 if _err != nil {
3607 return _result, _err
3608 }
3609 }
3610 query := map[string]interface{}{}
3611 if !dara.IsNil(request.InstanceId) {
3612 query["InstanceId"] = request.InstanceId
3613 }
3614
3615 if !dara.IsNil(request.Lang) {
3616 query["Lang"] = request.Lang
3617 }
3618
3619 req := &openapiutil.OpenApiRequest{
3620 Query: openapiutil.Query(query),
3621 }
3622 params := &openapiutil.Params{
3623 Action: dara.String("DescribeDnsGtmAddressPoolAvailableConfig"),
3624 Version: dara.String("2015-01-09"),
3625 Protocol: dara.String("HTTPS"),
3626 Pathname: dara.String("/"),
3627 Method: dara.String("POST"),
3628 AuthType: dara.String("AK"),
3629 Style: dara.String("RPC"),
3630 ReqBodyType: dara.String("formData"),
3631 BodyType: dara.String("json"),
3632 }
3633 _result = &DescribeDnsGtmAddressPoolAvailableConfigResponse{}
3634 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3635 if _err != nil {
3636 return _result, _err
3637 }
3638 _err = dara.Convert(_body, &_result)
3639 return _result, _err
3640 }
3641
3642 // @param request - DescribeDnsGtmAvailableAlertGroupRequest
3643 //
3644 // @param runtime - runtime options for this request RuntimeOptions
3645 //
3646 // @return DescribeDnsGtmAvailableAlertGroupResponse
3647 func DescribeDnsGtmAvailableAlertGroupWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmAvailableAlertGroupRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmAvailableAlertGroupResponse, _err error) {
3648 if dara.BoolValue(client.EnableValidate) == true {
3649 _err = request.Validate()
3650 if _err != nil {
3651 return _result, _err
3652 }
3653 }
3654 query := map[string]interface{}{}
3655 if !dara.IsNil(request.Lang) {
3656 query["Lang"] = request.Lang
3657 }
3658
3659 req := &openapiutil.OpenApiRequest{
3660 Query: openapiutil.Query(query),
3661 }
3662 params := &openapiutil.Params{
3663 Action: dara.String("DescribeDnsGtmAvailableAlertGroup"),
3664 Version: dara.String("2015-01-09"),
3665 Protocol: dara.String("HTTPS"),
3666 Pathname: dara.String("/"),
3667 Method: dara.String("POST"),
3668 AuthType: dara.String("AK"),
3669 Style: dara.String("RPC"),
3670 ReqBodyType: dara.String("formData"),
3671 BodyType: dara.String("json"),
3672 }
3673 _result = &DescribeDnsGtmAvailableAlertGroupResponse{}
3674 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3675 if _err != nil {
3676 return _result, _err
3677 }
3678 _err = dara.Convert(_body, &_result)
3679 return _result, _err
3680 }
3681
3682 // Summary:
3683 //
3684 // Queries detailed information about a Global Traffic Manager (GTM) instance.
3685 //
3686 // @param request - DescribeDnsGtmInstanceRequest
3687 //
3688 // @param runtime - runtime options for this request RuntimeOptions
3689 //
3690 // @return DescribeDnsGtmInstanceResponse
3691 func DescribeDnsGtmInstanceWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceResponse, _err error) {
3692 if dara.BoolValue(client.EnableValidate) == true {
3693 _err = request.Validate()
3694 if _err != nil {
3695 return _result, _err
3696 }
3697 }
3698 query := map[string]interface{}{}
3699 if !dara.IsNil(request.InstanceId) {
3700 query["InstanceId"] = request.InstanceId
3701 }
3702
3703 if !dara.IsNil(request.Lang) {
3704 query["Lang"] = request.Lang
3705 }
3706
3707 req := &openapiutil.OpenApiRequest{
3708 Query: openapiutil.Query(query),
3709 }
3710 params := &openapiutil.Params{
3711 Action: dara.String("DescribeDnsGtmInstance"),
3712 Version: dara.String("2015-01-09"),
3713 Protocol: dara.String("HTTPS"),
3714 Pathname: dara.String("/"),
3715 Method: dara.String("POST"),
3716 AuthType: dara.String("AK"),
3717 Style: dara.String("RPC"),
3718 ReqBodyType: dara.String("formData"),
3719 BodyType: dara.String("json"),
3720 }
3721 _result = &DescribeDnsGtmInstanceResponse{}
3722 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3723 if _err != nil {
3724 return _result, _err
3725 }
3726 _err = dara.Convert(_body, &_result)
3727 return _result, _err
3728 }
3729
3730 // Summary:
3731 //
3732 // Queries detailed information about an address pool of a Global Traffic Manager (GTM) instance.
3733 //
3734 // @param request - DescribeDnsGtmInstanceAddressPoolRequest
3735 //
3736 // @param runtime - runtime options for this request RuntimeOptions
3737 //
3738 // @return DescribeDnsGtmInstanceAddressPoolResponse
3739 func DescribeDnsGtmInstanceAddressPoolWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstanceAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceAddressPoolResponse, _err error) {
3740 if dara.BoolValue(client.EnableValidate) == true {
3741 _err = request.Validate()
3742 if _err != nil {
3743 return _result, _err
3744 }
3745 }
3746 query := map[string]interface{}{}
3747 if !dara.IsNil(request.AddrPoolId) {
3748 query["AddrPoolId"] = request.AddrPoolId
3749 }
3750
3751 if !dara.IsNil(request.Lang) {
3752 query["Lang"] = request.Lang
3753 }
3754
3755 req := &openapiutil.OpenApiRequest{
3756 Query: openapiutil.Query(query),
3757 }
3758 params := &openapiutil.Params{
3759 Action: dara.String("DescribeDnsGtmInstanceAddressPool"),
3760 Version: dara.String("2015-01-09"),
3761 Protocol: dara.String("HTTPS"),
3762 Pathname: dara.String("/"),
3763 Method: dara.String("POST"),
3764 AuthType: dara.String("AK"),
3765 Style: dara.String("RPC"),
3766 ReqBodyType: dara.String("formData"),
3767 BodyType: dara.String("json"),
3768 }
3769 _result = &DescribeDnsGtmInstanceAddressPoolResponse{}
3770 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3771 if _err != nil {
3772 return _result, _err
3773 }
3774 _err = dara.Convert(_body, &_result)
3775 return _result, _err
3776 }
3777
3778 // Summary:
3779 //
3780 // Queries the address pools of a Global Traffic Manager (GTM) instance.
3781 //
3782 // @param request - DescribeDnsGtmInstanceAddressPoolsRequest
3783 //
3784 // @param runtime - runtime options for this request RuntimeOptions
3785 //
3786 // @return DescribeDnsGtmInstanceAddressPoolsResponse
3787 func DescribeDnsGtmInstanceAddressPoolsWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstanceAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceAddressPoolsResponse, _err error) {
3788 if dara.BoolValue(client.EnableValidate) == true {
3789 _err = request.Validate()
3790 if _err != nil {
3791 return _result, _err
3792 }
3793 }
3794 query := map[string]interface{}{}
3795 if !dara.IsNil(request.InstanceId) {
3796 query["InstanceId"] = request.InstanceId
3797 }
3798
3799 if !dara.IsNil(request.Lang) {
3800 query["Lang"] = request.Lang
3801 }
3802
3803 if !dara.IsNil(request.PageNumber) {
3804 query["PageNumber"] = request.PageNumber
3805 }
3806
3807 if !dara.IsNil(request.PageSize) {
3808 query["PageSize"] = request.PageSize
3809 }
3810
3811 req := &openapiutil.OpenApiRequest{
3812 Query: openapiutil.Query(query),
3813 }
3814 params := &openapiutil.Params{
3815 Action: dara.String("DescribeDnsGtmInstanceAddressPools"),
3816 Version: dara.String("2015-01-09"),
3817 Protocol: dara.String("HTTPS"),
3818 Pathname: dara.String("/"),
3819 Method: dara.String("POST"),
3820 AuthType: dara.String("AK"),
3821 Style: dara.String("RPC"),
3822 ReqBodyType: dara.String("formData"),
3823 BodyType: dara.String("json"),
3824 }
3825 _result = &DescribeDnsGtmInstanceAddressPoolsResponse{}
3826 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3827 if _err != nil {
3828 return _result, _err
3829 }
3830 _err = dara.Convert(_body, &_result)
3831 return _result, _err
3832 }
3833
3834 // Summary:
3835 //
3836 // Queries the status of a Global Traffic Manager (GTM) instance.
3837 //
3838 // @param request - DescribeDnsGtmInstanceStatusRequest
3839 //
3840 // @param runtime - runtime options for this request RuntimeOptions
3841 //
3842 // @return DescribeDnsGtmInstanceStatusResponse
3843 func DescribeDnsGtmInstanceStatusWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceStatusResponse, _err error) {
3844 if dara.BoolValue(client.EnableValidate) == true {
3845 _err = request.Validate()
3846 if _err != nil {
3847 return _result, _err
3848 }
3849 }
3850 query := map[string]interface{}{}
3851 if !dara.IsNil(request.InstanceId) {
3852 query["InstanceId"] = request.InstanceId
3853 }
3854
3855 if !dara.IsNil(request.Lang) {
3856 query["Lang"] = request.Lang
3857 }
3858
3859 req := &openapiutil.OpenApiRequest{
3860 Query: openapiutil.Query(query),
3861 }
3862 params := &openapiutil.Params{
3863 Action: dara.String("DescribeDnsGtmInstanceStatus"),
3864 Version: dara.String("2015-01-09"),
3865 Protocol: dara.String("HTTPS"),
3866 Pathname: dara.String("/"),
3867 Method: dara.String("POST"),
3868 AuthType: dara.String("AK"),
3869 Style: dara.String("RPC"),
3870 ReqBodyType: dara.String("formData"),
3871 BodyType: dara.String("json"),
3872 }
3873 _result = &DescribeDnsGtmInstanceStatusResponse{}
3874 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3875 if _err != nil {
3876 return _result, _err
3877 }
3878 _err = dara.Convert(_body, &_result)
3879 return _result, _err
3880 }
3881
3882 // Summary:
3883 //
3884 // Queries the CNAME domain name assigned by the system for a Global Traffic Manager (GTM) instance.
3885 //
3886 // @param request - DescribeDnsGtmInstanceSystemCnameRequest
3887 //
3888 // @param runtime - runtime options for this request RuntimeOptions
3889 //
3890 // @return DescribeDnsGtmInstanceSystemCnameResponse
3891 func DescribeDnsGtmInstanceSystemCnameWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstanceSystemCnameRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstanceSystemCnameResponse, _err error) {
3892 if dara.BoolValue(client.EnableValidate) == true {
3893 _err = request.Validate()
3894 if _err != nil {
3895 return _result, _err
3896 }
3897 }
3898 query := map[string]interface{}{}
3899 if !dara.IsNil(request.InstanceId) {
3900 query["InstanceId"] = request.InstanceId
3901 }
3902
3903 if !dara.IsNil(request.Lang) {
3904 query["Lang"] = request.Lang
3905 }
3906
3907 req := &openapiutil.OpenApiRequest{
3908 Query: openapiutil.Query(query),
3909 }
3910 params := &openapiutil.Params{
3911 Action: dara.String("DescribeDnsGtmInstanceSystemCname"),
3912 Version: dara.String("2015-01-09"),
3913 Protocol: dara.String("HTTPS"),
3914 Pathname: dara.String("/"),
3915 Method: dara.String("POST"),
3916 AuthType: dara.String("AK"),
3917 Style: dara.String("RPC"),
3918 ReqBodyType: dara.String("formData"),
3919 BodyType: dara.String("json"),
3920 }
3921 _result = &DescribeDnsGtmInstanceSystemCnameResponse{}
3922 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3923 if _err != nil {
3924 return _result, _err
3925 }
3926 _err = dara.Convert(_body, &_result)
3927 return _result, _err
3928 }
3929
3930 // Summary:
3931 //
3932 // Queries a list of instances.
3933 //
3934 // @param request - DescribeDnsGtmInstancesRequest
3935 //
3936 // @param runtime - runtime options for this request RuntimeOptions
3937 //
3938 // @return DescribeDnsGtmInstancesResponse
3939 func DescribeDnsGtmInstancesWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmInstancesResponse, _err error) {
3940 if dara.BoolValue(client.EnableValidate) == true {
3941 _err = request.Validate()
3942 if _err != nil {
3943 return _result, _err
3944 }
3945 }
3946 query := map[string]interface{}{}
3947 if !dara.IsNil(request.Keyword) {
3948 query["Keyword"] = request.Keyword
3949 }
3950
3951 if !dara.IsNil(request.Lang) {
3952 query["Lang"] = request.Lang
3953 }
3954
3955 if !dara.IsNil(request.PageNumber) {
3956 query["PageNumber"] = request.PageNumber
3957 }
3958
3959 if !dara.IsNil(request.PageSize) {
3960 query["PageSize"] = request.PageSize
3961 }
3962
3963 if !dara.IsNil(request.ResourceGroupId) {
3964 query["ResourceGroupId"] = request.ResourceGroupId
3965 }
3966
3967 req := &openapiutil.OpenApiRequest{
3968 Query: openapiutil.Query(query),
3969 }
3970 params := &openapiutil.Params{
3971 Action: dara.String("DescribeDnsGtmInstances"),
3972 Version: dara.String("2015-01-09"),
3973 Protocol: dara.String("HTTPS"),
3974 Pathname: dara.String("/"),
3975 Method: dara.String("POST"),
3976 AuthType: dara.String("AK"),
3977 Style: dara.String("RPC"),
3978 ReqBodyType: dara.String("formData"),
3979 BodyType: dara.String("json"),
3980 }
3981 _result = &DescribeDnsGtmInstancesResponse{}
3982 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3983 if _err != nil {
3984 return _result, _err
3985 }
3986 _err = dara.Convert(_body, &_result)
3987 return _result, _err
3988 }
3989
3990 // Summary:
3991 //
3992 // Queries operation logs of a Global Traffic Manager (GTM) instance.
3993 //
3994 // @param request - DescribeDnsGtmLogsRequest
3995 //
3996 // @param runtime - runtime options for this request RuntimeOptions
3997 //
3998 // @return DescribeDnsGtmLogsResponse
3999 func DescribeDnsGtmLogsWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmLogsResponse, _err error) {
4000 if dara.BoolValue(client.EnableValidate) == true {
4001 _err = request.Validate()
4002 if _err != nil {
4003 return _result, _err
4004 }
4005 }
4006 query := map[string]interface{}{}
4007 if !dara.IsNil(request.EndTimestamp) {
4008 query["EndTimestamp"] = request.EndTimestamp
4009 }
4010
4011 if !dara.IsNil(request.InstanceId) {
4012 query["InstanceId"] = request.InstanceId
4013 }
4014
4015 if !dara.IsNil(request.Keyword) {
4016 query["Keyword"] = request.Keyword
4017 }
4018
4019 if !dara.IsNil(request.Lang) {
4020 query["Lang"] = request.Lang
4021 }
4022
4023 if !dara.IsNil(request.PageNumber) {
4024 query["PageNumber"] = request.PageNumber
4025 }
4026
4027 if !dara.IsNil(request.PageSize) {
4028 query["PageSize"] = request.PageSize
4029 }
4030
4031 if !dara.IsNil(request.StartTimestamp) {
4032 query["StartTimestamp"] = request.StartTimestamp
4033 }
4034
4035 req := &openapiutil.OpenApiRequest{
4036 Query: openapiutil.Query(query),
4037 }
4038 params := &openapiutil.Params{
4039 Action: dara.String("DescribeDnsGtmLogs"),
4040 Version: dara.String("2015-01-09"),
4041 Protocol: dara.String("HTTPS"),
4042 Pathname: dara.String("/"),
4043 Method: dara.String("POST"),
4044 AuthType: dara.String("AK"),
4045 Style: dara.String("RPC"),
4046 ReqBodyType: dara.String("formData"),
4047 BodyType: dara.String("json"),
4048 }
4049 _result = &DescribeDnsGtmLogsResponse{}
4050 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4051 if _err != nil {
4052 return _result, _err
4053 }
4054 _err = dara.Convert(_body, &_result)
4055 return _result, _err
4056 }
4057
4058 // Summary:
4059 //
4060 // Queries the configuration items that can be set for a health check task.
4061 //
4062 // @param request - DescribeDnsGtmMonitorAvailableConfigRequest
4063 //
4064 // @param runtime - runtime options for this request RuntimeOptions
4065 //
4066 // @return DescribeDnsGtmMonitorAvailableConfigResponse
4067 func DescribeDnsGtmMonitorAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmMonitorAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmMonitorAvailableConfigResponse, _err error) {
4068 if dara.BoolValue(client.EnableValidate) == true {
4069 _err = request.Validate()
4070 if _err != nil {
4071 return _result, _err
4072 }
4073 }
4074 query := map[string]interface{}{}
4075 if !dara.IsNil(request.Lang) {
4076 query["Lang"] = request.Lang
4077 }
4078
4079 req := &openapiutil.OpenApiRequest{
4080 Query: openapiutil.Query(query),
4081 }
4082 params := &openapiutil.Params{
4083 Action: dara.String("DescribeDnsGtmMonitorAvailableConfig"),
4084 Version: dara.String("2015-01-09"),
4085 Protocol: dara.String("HTTPS"),
4086 Pathname: dara.String("/"),
4087 Method: dara.String("POST"),
4088 AuthType: dara.String("AK"),
4089 Style: dara.String("RPC"),
4090 ReqBodyType: dara.String("formData"),
4091 BodyType: dara.String("json"),
4092 }
4093 _result = &DescribeDnsGtmMonitorAvailableConfigResponse{}
4094 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4095 if _err != nil {
4096 return _result, _err
4097 }
4098 _err = dara.Convert(_body, &_result)
4099 return _result, _err
4100 }
4101
4102 // Summary:
4103 //
4104 // Queries the health check configuration of an address pool.
4105 //
4106 // @param request - DescribeDnsGtmMonitorConfigRequest
4107 //
4108 // @param runtime - runtime options for this request RuntimeOptions
4109 //
4110 // @return DescribeDnsGtmMonitorConfigResponse
4111 func DescribeDnsGtmMonitorConfigWithContext(ctx context.Context, client *Client, request *DescribeDnsGtmMonitorConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsGtmMonitorConfigResponse, _err error) {
4112 if dara.BoolValue(client.EnableValidate) == true {
4113 _err = request.Validate()
4114 if _err != nil {
4115 return _result, _err
4116 }
4117 }
4118 query := map[string]interface{}{}
4119 if !dara.IsNil(request.Lang) {
4120 query["Lang"] = request.Lang
4121 }
4122
4123 if !dara.IsNil(request.MonitorConfigId) {
4124 query["MonitorConfigId"] = request.MonitorConfigId
4125 }
4126
4127 req := &openapiutil.OpenApiRequest{
4128 Query: openapiutil.Query(query),
4129 }
4130 params := &openapiutil.Params{
4131 Action: dara.String("DescribeDnsGtmMonitorConfig"),
4132 Version: dara.String("2015-01-09"),
4133 Protocol: dara.String("HTTPS"),
4134 Pathname: dara.String("/"),
4135 Method: dara.String("POST"),
4136 AuthType: dara.String("AK"),
4137 Style: dara.String("RPC"),
4138 ReqBodyType: dara.String("formData"),
4139 BodyType: dara.String("json"),
4140 }
4141 _result = &DescribeDnsGtmMonitorConfigResponse{}
4142 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4143 if _err != nil {
4144 return _result, _err
4145 }
4146 _err = dara.Convert(_body, &_result)
4147 return _result, _err
4148 }
4149
4150 // Summary:
4151 //
4152 // Queries the details about a paid Alibaba Cloud DNS instance based on the instance ID.
4153 //
4154 // @param request - DescribeDnsProductInstanceRequest
4155 //
4156 // @param runtime - runtime options for this request RuntimeOptions
4157 //
4158 // @return DescribeDnsProductInstanceResponse
4159 func DescribeDnsProductInstanceWithContext(ctx context.Context, client *Client, request *DescribeDnsProductInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsProductInstanceResponse, _err error) {
4160 if dara.BoolValue(client.EnableValidate) == true {
4161 _err = request.Validate()
4162 if _err != nil {
4163 return _result, _err
4164 }
4165 }
4166 query := map[string]interface{}{}
4167 if !dara.IsNil(request.InstanceId) {
4168 query["InstanceId"] = request.InstanceId
4169 }
4170
4171 if !dara.IsNil(request.Lang) {
4172 query["Lang"] = request.Lang
4173 }
4174
4175 if !dara.IsNil(request.UserClientIp) {
4176 query["UserClientIp"] = request.UserClientIp
4177 }
4178
4179 req := &openapiutil.OpenApiRequest{
4180 Query: openapiutil.Query(query),
4181 }
4182 params := &openapiutil.Params{
4183 Action: dara.String("DescribeDnsProductInstance"),
4184 Version: dara.String("2015-01-09"),
4185 Protocol: dara.String("HTTPS"),
4186 Pathname: dara.String("/"),
4187 Method: dara.String("POST"),
4188 AuthType: dara.String("AK"),
4189 Style: dara.String("RPC"),
4190 ReqBodyType: dara.String("formData"),
4191 BodyType: dara.String("json"),
4192 }
4193 _result = &DescribeDnsProductInstanceResponse{}
4194 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4195 if _err != nil {
4196 return _result, _err
4197 }
4198 _err = dara.Convert(_body, &_result)
4199 return _result, _err
4200 }
4201
4202 // Summary:
4203 //
4204 // Calls the DescribeDnsProductInstances operation to query the list of paid Alibaba Cloud DNS instances based on input parameters.
4205 //
4206 // Description:
4207 //
4208 // > If the response parameters of an Alibaba Cloud DNS instance do not contain domain names, no domain names are bound to the instance.
4209 //
4210 // @param request - DescribeDnsProductInstancesRequest
4211 //
4212 // @param runtime - runtime options for this request RuntimeOptions
4213 //
4214 // @return DescribeDnsProductInstancesResponse
4215 func DescribeDnsProductInstancesWithContext(ctx context.Context, client *Client, request *DescribeDnsProductInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeDnsProductInstancesResponse, _err error) {
4216 if dara.BoolValue(client.EnableValidate) == true {
4217 _err = request.Validate()
4218 if _err != nil {
4219 return _result, _err
4220 }
4221 }
4222 query := map[string]interface{}{}
4223 if !dara.IsNil(request.Direction) {
4224 query["Direction"] = request.Direction
4225 }
4226
4227 if !dara.IsNil(request.DomainType) {
4228 query["DomainType"] = request.DomainType
4229 }
4230
4231 if !dara.IsNil(request.Lang) {
4232 query["Lang"] = request.Lang
4233 }
4234
4235 if !dara.IsNil(request.OrderBy) {
4236 query["OrderBy"] = request.OrderBy
4237 }
4238
4239 if !dara.IsNil(request.PageNumber) {
4240 query["PageNumber"] = request.PageNumber
4241 }
4242
4243 if !dara.IsNil(request.PageSize) {
4244 query["PageSize"] = request.PageSize
4245 }
4246
4247 if !dara.IsNil(request.UserClientIp) {
4248 query["UserClientIp"] = request.UserClientIp
4249 }
4250
4251 if !dara.IsNil(request.VersionCode) {
4252 query["VersionCode"] = request.VersionCode
4253 }
4254
4255 req := &openapiutil.OpenApiRequest{
4256 Query: openapiutil.Query(query),
4257 }
4258 params := &openapiutil.Params{
4259 Action: dara.String("DescribeDnsProductInstances"),
4260 Version: dara.String("2015-01-09"),
4261 Protocol: dara.String("HTTPS"),
4262 Pathname: dara.String("/"),
4263 Method: dara.String("POST"),
4264 AuthType: dara.String("AK"),
4265 Style: dara.String("RPC"),
4266 ReqBodyType: dara.String("formData"),
4267 BodyType: dara.String("json"),
4268 }
4269 _result = &DescribeDnsProductInstancesResponse{}
4270 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4271 if _err != nil {
4272 return _result, _err
4273 }
4274 _err = dara.Convert(_body, &_result)
4275 return _result, _err
4276 }
4277
4278 // @param request - DescribeDohAccountStatisticsRequest
4279 //
4280 // @param runtime - runtime options for this request RuntimeOptions
4281 //
4282 // @return DescribeDohAccountStatisticsResponse
4283 func DescribeDohAccountStatisticsWithContext(ctx context.Context, client *Client, request *DescribeDohAccountStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohAccountStatisticsResponse, _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.EndDate) {
4292 query["EndDate"] = request.EndDate
4293 }
4294
4295 if !dara.IsNil(request.Lang) {
4296 query["Lang"] = request.Lang
4297 }
4298
4299 if !dara.IsNil(request.StartDate) {
4300 query["StartDate"] = request.StartDate
4301 }
4302
4303 req := &openapiutil.OpenApiRequest{
4304 Query: openapiutil.Query(query),
4305 }
4306 params := &openapiutil.Params{
4307 Action: dara.String("DescribeDohAccountStatistics"),
4308 Version: dara.String("2015-01-09"),
4309 Protocol: dara.String("HTTPS"),
4310 Pathname: dara.String("/"),
4311 Method: dara.String("POST"),
4312 AuthType: dara.String("AK"),
4313 Style: dara.String("RPC"),
4314 ReqBodyType: dara.String("formData"),
4315 BodyType: dara.String("json"),
4316 }
4317 _result = &DescribeDohAccountStatisticsResponse{}
4318 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4319 if _err != nil {
4320 return _result, _err
4321 }
4322 _err = dara.Convert(_body, &_result)
4323 return _result, _err
4324 }
4325
4326 // Summary:
4327 //
4328 // 查询DOH域名请求量数据
4329 //
4330 // @param request - DescribeDohDomainStatisticsRequest
4331 //
4332 // @param runtime - runtime options for this request RuntimeOptions
4333 //
4334 // @return DescribeDohDomainStatisticsResponse
4335 func DescribeDohDomainStatisticsWithContext(ctx context.Context, client *Client, request *DescribeDohDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohDomainStatisticsResponse, _err error) {
4336 if dara.BoolValue(client.EnableValidate) == true {
4337 _err = request.Validate()
4338 if _err != nil {
4339 return _result, _err
4340 }
4341 }
4342 query := map[string]interface{}{}
4343 if !dara.IsNil(request.DomainName) {
4344 query["DomainName"] = request.DomainName
4345 }
4346
4347 if !dara.IsNil(request.EndDate) {
4348 query["EndDate"] = request.EndDate
4349 }
4350
4351 if !dara.IsNil(request.Lang) {
4352 query["Lang"] = request.Lang
4353 }
4354
4355 if !dara.IsNil(request.StartDate) {
4356 query["StartDate"] = request.StartDate
4357 }
4358
4359 req := &openapiutil.OpenApiRequest{
4360 Query: openapiutil.Query(query),
4361 }
4362 params := &openapiutil.Params{
4363 Action: dara.String("DescribeDohDomainStatistics"),
4364 Version: dara.String("2015-01-09"),
4365 Protocol: dara.String("HTTPS"),
4366 Pathname: dara.String("/"),
4367 Method: dara.String("POST"),
4368 AuthType: dara.String("AK"),
4369 Style: dara.String("RPC"),
4370 ReqBodyType: dara.String("formData"),
4371 BodyType: dara.String("json"),
4372 }
4373 _result = &DescribeDohDomainStatisticsResponse{}
4374 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4375 if _err != nil {
4376 return _result, _err
4377 }
4378 _err = dara.Convert(_body, &_result)
4379 return _result, _err
4380 }
4381
4382 // @param request - DescribeDohDomainStatisticsSummaryRequest
4383 //
4384 // @param runtime - runtime options for this request RuntimeOptions
4385 //
4386 // @return DescribeDohDomainStatisticsSummaryResponse
4387 func DescribeDohDomainStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeDohDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohDomainStatisticsSummaryResponse, _err error) {
4388 if dara.BoolValue(client.EnableValidate) == true {
4389 _err = request.Validate()
4390 if _err != nil {
4391 return _result, _err
4392 }
4393 }
4394 query := map[string]interface{}{}
4395 if !dara.IsNil(request.DomainName) {
4396 query["DomainName"] = request.DomainName
4397 }
4398
4399 if !dara.IsNil(request.EndDate) {
4400 query["EndDate"] = request.EndDate
4401 }
4402
4403 if !dara.IsNil(request.Lang) {
4404 query["Lang"] = request.Lang
4405 }
4406
4407 if !dara.IsNil(request.PageNumber) {
4408 query["PageNumber"] = request.PageNumber
4409 }
4410
4411 if !dara.IsNil(request.PageSize) {
4412 query["PageSize"] = request.PageSize
4413 }
4414
4415 if !dara.IsNil(request.StartDate) {
4416 query["StartDate"] = request.StartDate
4417 }
4418
4419 req := &openapiutil.OpenApiRequest{
4420 Query: openapiutil.Query(query),
4421 }
4422 params := &openapiutil.Params{
4423 Action: dara.String("DescribeDohDomainStatisticsSummary"),
4424 Version: dara.String("2015-01-09"),
4425 Protocol: dara.String("HTTPS"),
4426 Pathname: dara.String("/"),
4427 Method: dara.String("POST"),
4428 AuthType: dara.String("AK"),
4429 Style: dara.String("RPC"),
4430 ReqBodyType: dara.String("formData"),
4431 BodyType: dara.String("json"),
4432 }
4433 _result = &DescribeDohDomainStatisticsSummaryResponse{}
4434 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4435 if _err != nil {
4436 return _result, _err
4437 }
4438 _err = dara.Convert(_body, &_result)
4439 return _result, _err
4440 }
4441
4442 // @param request - DescribeDohSubDomainStatisticsRequest
4443 //
4444 // @param runtime - runtime options for this request RuntimeOptions
4445 //
4446 // @return DescribeDohSubDomainStatisticsResponse
4447 func DescribeDohSubDomainStatisticsWithContext(ctx context.Context, client *Client, request *DescribeDohSubDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohSubDomainStatisticsResponse, _err error) {
4448 if dara.BoolValue(client.EnableValidate) == true {
4449 _err = request.Validate()
4450 if _err != nil {
4451 return _result, _err
4452 }
4453 }
4454 query := map[string]interface{}{}
4455 if !dara.IsNil(request.EndDate) {
4456 query["EndDate"] = request.EndDate
4457 }
4458
4459 if !dara.IsNil(request.Lang) {
4460 query["Lang"] = request.Lang
4461 }
4462
4463 if !dara.IsNil(request.StartDate) {
4464 query["StartDate"] = request.StartDate
4465 }
4466
4467 if !dara.IsNil(request.SubDomain) {
4468 query["SubDomain"] = request.SubDomain
4469 }
4470
4471 req := &openapiutil.OpenApiRequest{
4472 Query: openapiutil.Query(query),
4473 }
4474 params := &openapiutil.Params{
4475 Action: dara.String("DescribeDohSubDomainStatistics"),
4476 Version: dara.String("2015-01-09"),
4477 Protocol: dara.String("HTTPS"),
4478 Pathname: dara.String("/"),
4479 Method: dara.String("POST"),
4480 AuthType: dara.String("AK"),
4481 Style: dara.String("RPC"),
4482 ReqBodyType: dara.String("formData"),
4483 BodyType: dara.String("json"),
4484 }
4485 _result = &DescribeDohSubDomainStatisticsResponse{}
4486 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4487 if _err != nil {
4488 return _result, _err
4489 }
4490 _err = dara.Convert(_body, &_result)
4491 return _result, _err
4492 }
4493
4494 // @param request - DescribeDohSubDomainStatisticsSummaryRequest
4495 //
4496 // @param runtime - runtime options for this request RuntimeOptions
4497 //
4498 // @return DescribeDohSubDomainStatisticsSummaryResponse
4499 func DescribeDohSubDomainStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeDohSubDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohSubDomainStatisticsSummaryResponse, _err error) {
4500 if dara.BoolValue(client.EnableValidate) == true {
4501 _err = request.Validate()
4502 if _err != nil {
4503 return _result, _err
4504 }
4505 }
4506 query := map[string]interface{}{}
4507 if !dara.IsNil(request.DomainName) {
4508 query["DomainName"] = request.DomainName
4509 }
4510
4511 if !dara.IsNil(request.EndDate) {
4512 query["EndDate"] = request.EndDate
4513 }
4514
4515 if !dara.IsNil(request.Lang) {
4516 query["Lang"] = request.Lang
4517 }
4518
4519 if !dara.IsNil(request.PageNumber) {
4520 query["PageNumber"] = request.PageNumber
4521 }
4522
4523 if !dara.IsNil(request.PageSize) {
4524 query["PageSize"] = request.PageSize
4525 }
4526
4527 if !dara.IsNil(request.StartDate) {
4528 query["StartDate"] = request.StartDate
4529 }
4530
4531 if !dara.IsNil(request.SubDomain) {
4532 query["SubDomain"] = request.SubDomain
4533 }
4534
4535 req := &openapiutil.OpenApiRequest{
4536 Query: openapiutil.Query(query),
4537 }
4538 params := &openapiutil.Params{
4539 Action: dara.String("DescribeDohSubDomainStatisticsSummary"),
4540 Version: dara.String("2015-01-09"),
4541 Protocol: dara.String("HTTPS"),
4542 Pathname: dara.String("/"),
4543 Method: dara.String("POST"),
4544 AuthType: dara.String("AK"),
4545 Style: dara.String("RPC"),
4546 ReqBodyType: dara.String("formData"),
4547 BodyType: dara.String("json"),
4548 }
4549 _result = &DescribeDohSubDomainStatisticsSummaryResponse{}
4550 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4551 if _err != nil {
4552 return _result, _err
4553 }
4554 _err = dara.Convert(_body, &_result)
4555 return _result, _err
4556 }
4557
4558 // Summary:
4559 //
4560 // Queries the numbers of accessed domains and subdomains by using DNS over HTTPS (DoH).
4561 //
4562 // @param request - DescribeDohUserInfoRequest
4563 //
4564 // @param runtime - runtime options for this request RuntimeOptions
4565 //
4566 // @return DescribeDohUserInfoResponse
4567 func DescribeDohUserInfoWithContext(ctx context.Context, client *Client, request *DescribeDohUserInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDohUserInfoResponse, _err error) {
4568 if dara.BoolValue(client.EnableValidate) == true {
4569 _err = request.Validate()
4570 if _err != nil {
4571 return _result, _err
4572 }
4573 }
4574 query := map[string]interface{}{}
4575 if !dara.IsNil(request.EndDate) {
4576 query["EndDate"] = request.EndDate
4577 }
4578
4579 if !dara.IsNil(request.Lang) {
4580 query["Lang"] = request.Lang
4581 }
4582
4583 if !dara.IsNil(request.StartDate) {
4584 query["StartDate"] = request.StartDate
4585 }
4586
4587 req := &openapiutil.OpenApiRequest{
4588 Query: openapiutil.Query(query),
4589 }
4590 params := &openapiutil.Params{
4591 Action: dara.String("DescribeDohUserInfo"),
4592 Version: dara.String("2015-01-09"),
4593 Protocol: dara.String("HTTPS"),
4594 Pathname: dara.String("/"),
4595 Method: dara.String("POST"),
4596 AuthType: dara.String("AK"),
4597 Style: dara.String("RPC"),
4598 ReqBodyType: dara.String("formData"),
4599 BodyType: dara.String("json"),
4600 }
4601 _result = &DescribeDohUserInfoResponse{}
4602 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4603 if _err != nil {
4604 return _result, _err
4605 }
4606 _err = dara.Convert(_body, &_result)
4607 return _result, _err
4608 }
4609
4610 // Summary:
4611 //
4612 // Queries the Domain Name System Security Extensions (DNSSEC) configurations of a domain name based on the specified parameters.
4613 //
4614 // @param request - DescribeDomainDnssecInfoRequest
4615 //
4616 // @param runtime - runtime options for this request RuntimeOptions
4617 //
4618 // @return DescribeDomainDnssecInfoResponse
4619 func DescribeDomainDnssecInfoWithContext(ctx context.Context, client *Client, request *DescribeDomainDnssecInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainDnssecInfoResponse, _err error) {
4620 if dara.BoolValue(client.EnableValidate) == true {
4621 _err = request.Validate()
4622 if _err != nil {
4623 return _result, _err
4624 }
4625 }
4626 query := map[string]interface{}{}
4627 if !dara.IsNil(request.DomainName) {
4628 query["DomainName"] = request.DomainName
4629 }
4630
4631 if !dara.IsNil(request.Lang) {
4632 query["Lang"] = request.Lang
4633 }
4634
4635 req := &openapiutil.OpenApiRequest{
4636 Query: openapiutil.Query(query),
4637 }
4638 params := &openapiutil.Params{
4639 Action: dara.String("DescribeDomainDnssecInfo"),
4640 Version: dara.String("2015-01-09"),
4641 Protocol: dara.String("HTTPS"),
4642 Pathname: dara.String("/"),
4643 Method: dara.String("POST"),
4644 AuthType: dara.String("AK"),
4645 Style: dara.String("RPC"),
4646 ReqBodyType: dara.String("formData"),
4647 BodyType: dara.String("json"),
4648 }
4649 _result = &DescribeDomainDnssecInfoResponse{}
4650 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4651 if _err != nil {
4652 return _result, _err
4653 }
4654 _err = dara.Convert(_body, &_result)
4655 return _result, _err
4656 }
4657
4658 // Summary:
4659 //
4660 // Queries all domain name groups based on the specified parameters.
4661 //
4662 // @param request - DescribeDomainGroupsRequest
4663 //
4664 // @param runtime - runtime options for this request RuntimeOptions
4665 //
4666 // @return DescribeDomainGroupsResponse
4667 func DescribeDomainGroupsWithContext(ctx context.Context, client *Client, request *DescribeDomainGroupsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainGroupsResponse, _err error) {
4668 if dara.BoolValue(client.EnableValidate) == true {
4669 _err = request.Validate()
4670 if _err != nil {
4671 return _result, _err
4672 }
4673 }
4674 query := map[string]interface{}{}
4675 if !dara.IsNil(request.KeyWord) {
4676 query["KeyWord"] = request.KeyWord
4677 }
4678
4679 if !dara.IsNil(request.Lang) {
4680 query["Lang"] = request.Lang
4681 }
4682
4683 if !dara.IsNil(request.PageNumber) {
4684 query["PageNumber"] = request.PageNumber
4685 }
4686
4687 if !dara.IsNil(request.PageSize) {
4688 query["PageSize"] = request.PageSize
4689 }
4690
4691 req := &openapiutil.OpenApiRequest{
4692 Query: openapiutil.Query(query),
4693 }
4694 params := &openapiutil.Params{
4695 Action: dara.String("DescribeDomainGroups"),
4696 Version: dara.String("2015-01-09"),
4697 Protocol: dara.String("HTTPS"),
4698 Pathname: dara.String("/"),
4699 Method: dara.String("POST"),
4700 AuthType: dara.String("AK"),
4701 Style: dara.String("RPC"),
4702 ReqBodyType: dara.String("formData"),
4703 BodyType: dara.String("json"),
4704 }
4705 _result = &DescribeDomainGroupsResponse{}
4706 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4707 if _err != nil {
4708 return _result, _err
4709 }
4710 _err = dara.Convert(_body, &_result)
4711 return _result, _err
4712 }
4713
4714 // Summary:
4715 //
4716 // Queries the information about a domain name based on specified parameters.
4717 //
4718 // Description:
4719 //
4720 // 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.
4721 //
4722 // @param request - DescribeDomainInfoRequest
4723 //
4724 // @param runtime - runtime options for this request RuntimeOptions
4725 //
4726 // @return DescribeDomainInfoResponse
4727 func DescribeDomainInfoWithContext(ctx context.Context, client *Client, request *DescribeDomainInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainInfoResponse, _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.DomainName) {
4736 query["DomainName"] = request.DomainName
4737 }
4738
4739 if !dara.IsNil(request.Lang) {
4740 query["Lang"] = request.Lang
4741 }
4742
4743 if !dara.IsNil(request.NeedDetailAttributes) {
4744 query["NeedDetailAttributes"] = request.NeedDetailAttributes
4745 }
4746
4747 req := &openapiutil.OpenApiRequest{
4748 Query: openapiutil.Query(query),
4749 }
4750 params := &openapiutil.Params{
4751 Action: dara.String("DescribeDomainInfo"),
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 = &DescribeDomainInfoResponse{}
4762 _body, _err := client.CallApiWithCtx(ctx, 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 operation logs of domain names based on the specified parameters.
4773 //
4774 // @param request - DescribeDomainLogsRequest
4775 //
4776 // @param runtime - runtime options for this request RuntimeOptions
4777 //
4778 // @return DescribeDomainLogsResponse
4779 func DescribeDomainLogsWithContext(ctx context.Context, client *Client, request *DescribeDomainLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainLogsResponse, _err error) {
4780 if dara.BoolValue(client.EnableValidate) == true {
4781 _err = request.Validate()
4782 if _err != nil {
4783 return _result, _err
4784 }
4785 }
4786 query := map[string]interface{}{}
4787 if !dara.IsNil(request.GroupId) {
4788 query["GroupId"] = request.GroupId
4789 }
4790
4791 if !dara.IsNil(request.KeyWord) {
4792 query["KeyWord"] = request.KeyWord
4793 }
4794
4795 if !dara.IsNil(request.Lang) {
4796 query["Lang"] = request.Lang
4797 }
4798
4799 if !dara.IsNil(request.PageNumber) {
4800 query["PageNumber"] = request.PageNumber
4801 }
4802
4803 if !dara.IsNil(request.PageSize) {
4804 query["PageSize"] = request.PageSize
4805 }
4806
4807 if !dara.IsNil(request.StartDate) {
4808 query["StartDate"] = request.StartDate
4809 }
4810
4811 if !dara.IsNil(request.Type) {
4812 query["Type"] = request.Type
4813 }
4814
4815 if !dara.IsNil(request.EndDate) {
4816 query["endDate"] = request.EndDate
4817 }
4818
4819 req := &openapiutil.OpenApiRequest{
4820 Query: openapiutil.Query(query),
4821 }
4822 params := &openapiutil.Params{
4823 Action: dara.String("DescribeDomainLogs"),
4824 Version: dara.String("2015-01-09"),
4825 Protocol: dara.String("HTTPS"),
4826 Pathname: dara.String("/"),
4827 Method: dara.String("POST"),
4828 AuthType: dara.String("AK"),
4829 Style: dara.String("RPC"),
4830 ReqBodyType: dara.String("formData"),
4831 BodyType: dara.String("json"),
4832 }
4833 _result = &DescribeDomainLogsResponse{}
4834 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4835 if _err != nil {
4836 return _result, _err
4837 }
4838 _err = dara.Convert(_body, &_result)
4839 return _result, _err
4840 }
4841
4842 // Summary:
4843 //
4844 // 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.
4845 //
4846 // Description:
4847 //
4848 // > 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.
4849 //
4850 // @param request - DescribeDomainNsRequest
4851 //
4852 // @param runtime - runtime options for this request RuntimeOptions
4853 //
4854 // @return DescribeDomainNsResponse
4855 func DescribeDomainNsWithContext(ctx context.Context, client *Client, request *DescribeDomainNsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainNsResponse, _err error) {
4856 if dara.BoolValue(client.EnableValidate) == true {
4857 _err = request.Validate()
4858 if _err != nil {
4859 return _result, _err
4860 }
4861 }
4862 query := map[string]interface{}{}
4863 if !dara.IsNil(request.DomainName) {
4864 query["DomainName"] = request.DomainName
4865 }
4866
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("DescribeDomainNs"),
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 = &DescribeDomainNsResponse{}
4886 _body, _err := client.CallApiWithCtx(ctx, 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 // Summary:
4895 //
4896 // Queries the information about a Domain Name System (DNS) record by the ID of the DNS record.
4897 //
4898 // Description:
4899 //
4900 // ## Debugging
4901 //
4902 // [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)
4903 //
4904 // @param request - DescribeDomainRecordInfoRequest
4905 //
4906 // @param runtime - runtime options for this request RuntimeOptions
4907 //
4908 // @return DescribeDomainRecordInfoResponse
4909 func DescribeDomainRecordInfoWithContext(ctx context.Context, client *Client, request *DescribeDomainRecordInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainRecordInfoResponse, _err error) {
4910 if dara.BoolValue(client.EnableValidate) == true {
4911 _err = request.Validate()
4912 if _err != nil {
4913 return _result, _err
4914 }
4915 }
4916 query := map[string]interface{}{}
4917 if !dara.IsNil(request.Lang) {
4918 query["Lang"] = request.Lang
4919 }
4920
4921 if !dara.IsNil(request.RecordId) {
4922 query["RecordId"] = request.RecordId
4923 }
4924
4925 if !dara.IsNil(request.UserClientIp) {
4926 query["UserClientIp"] = request.UserClientIp
4927 }
4928
4929 req := &openapiutil.OpenApiRequest{
4930 Query: openapiutil.Query(query),
4931 }
4932 params := &openapiutil.Params{
4933 Action: dara.String("DescribeDomainRecordInfo"),
4934 Version: dara.String("2015-01-09"),
4935 Protocol: dara.String("HTTPS"),
4936 Pathname: dara.String("/"),
4937 Method: dara.String("POST"),
4938 AuthType: dara.String("AK"),
4939 Style: dara.String("RPC"),
4940 ReqBodyType: dara.String("formData"),
4941 BodyType: dara.String("json"),
4942 }
4943 _result = &DescribeDomainRecordInfoResponse{}
4944 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4945 if _err != nil {
4946 return _result, _err
4947 }
4948 _err = dara.Convert(_body, &_result)
4949 return _result, _err
4950 }
4951
4952 // Summary:
4953 //
4954 // Queries all Domain Name System (DNS) records of the specified primary domain names based on the specified parameters.
4955 //
4956 // Description:
4957 //
4958 // You can specify DomainName, PageNumber, and PageSize to query the DNS records of the specified domain names.
4959 //
4960 // - You can also specify RRKeyWord, TypeKeyWord, or ValueKeyWord to query the DNS records that contain the specified keyword.
4961 //
4962 // - By default, the DNS records are sorted in reverse chronological order based on the time when they were added.
4963 //
4964 // - 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.
4965 //
4966 // @param request - DescribeDomainRecordsRequest
4967 //
4968 // @param runtime - runtime options for this request RuntimeOptions
4969 //
4970 // @return DescribeDomainRecordsResponse
4971 func DescribeDomainRecordsWithContext(ctx context.Context, client *Client, request *DescribeDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainRecordsResponse, _err error) {
4972 if dara.BoolValue(client.EnableValidate) == true {
4973 _err = request.Validate()
4974 if _err != nil {
4975 return _result, _err
4976 }
4977 }
4978 query := map[string]interface{}{}
4979 if !dara.IsNil(request.Direction) {
4980 query["Direction"] = request.Direction
4981 }
4982
4983 if !dara.IsNil(request.DomainName) {
4984 query["DomainName"] = request.DomainName
4985 }
4986
4987 if !dara.IsNil(request.GroupId) {
4988 query["GroupId"] = request.GroupId
4989 }
4990
4991 if !dara.IsNil(request.KeyWord) {
4992 query["KeyWord"] = request.KeyWord
4993 }
4994
4995 if !dara.IsNil(request.Lang) {
4996 query["Lang"] = request.Lang
4997 }
4998
4999 if !dara.IsNil(request.Line) {
5000 query["Line"] = request.Line
5001 }
5002
5003 if !dara.IsNil(request.OrderBy) {
5004 query["OrderBy"] = request.OrderBy
5005 }
5006
5007 if !dara.IsNil(request.PageNumber) {
5008 query["PageNumber"] = request.PageNumber
5009 }
5010
5011 if !dara.IsNil(request.PageSize) {
5012 query["PageSize"] = request.PageSize
5013 }
5014
5015 if !dara.IsNil(request.RRKeyWord) {
5016 query["RRKeyWord"] = request.RRKeyWord
5017 }
5018
5019 if !dara.IsNil(request.SearchMode) {
5020 query["SearchMode"] = request.SearchMode
5021 }
5022
5023 if !dara.IsNil(request.Status) {
5024 query["Status"] = request.Status
5025 }
5026
5027 if !dara.IsNil(request.Type) {
5028 query["Type"] = request.Type
5029 }
5030
5031 if !dara.IsNil(request.TypeKeyWord) {
5032 query["TypeKeyWord"] = request.TypeKeyWord
5033 }
5034
5035 if !dara.IsNil(request.ValueKeyWord) {
5036 query["ValueKeyWord"] = request.ValueKeyWord
5037 }
5038
5039 req := &openapiutil.OpenApiRequest{
5040 Query: openapiutil.Query(query),
5041 }
5042 params := &openapiutil.Params{
5043 Action: dara.String("DescribeDomainRecords"),
5044 Version: dara.String("2015-01-09"),
5045 Protocol: dara.String("HTTPS"),
5046 Pathname: dara.String("/"),
5047 Method: dara.String("POST"),
5048 AuthType: dara.String("AK"),
5049 Style: dara.String("RPC"),
5050 ReqBodyType: dara.String("formData"),
5051 BodyType: dara.String("json"),
5052 }
5053 _result = &DescribeDomainRecordsResponse{}
5054 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5055 if _err != nil {
5056 return _result, _err
5057 }
5058 _err = dara.Convert(_body, &_result)
5059 return _result, _err
5060 }
5061
5062 // Summary:
5063 //
5064 // Queries the resolution requests of all paid domain names within your account.
5065 //
5066 // @param request - DescribeDomainResolveStatisticsSummaryRequest
5067 //
5068 // @param runtime - runtime options for this request RuntimeOptions
5069 //
5070 // @return DescribeDomainResolveStatisticsSummaryResponse
5071 func DescribeDomainResolveStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeDomainResolveStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainResolveStatisticsSummaryResponse, _err error) {
5072 if dara.BoolValue(client.EnableValidate) == true {
5073 _err = request.Validate()
5074 if _err != nil {
5075 return _result, _err
5076 }
5077 }
5078 query := map[string]interface{}{}
5079 if !dara.IsNil(request.Direction) {
5080 query["Direction"] = request.Direction
5081 }
5082
5083 if !dara.IsNil(request.EndDate) {
5084 query["EndDate"] = request.EndDate
5085 }
5086
5087 if !dara.IsNil(request.Keyword) {
5088 query["Keyword"] = request.Keyword
5089 }
5090
5091 if !dara.IsNil(request.Lang) {
5092 query["Lang"] = request.Lang
5093 }
5094
5095 if !dara.IsNil(request.PageNumber) {
5096 query["PageNumber"] = request.PageNumber
5097 }
5098
5099 if !dara.IsNil(request.PageSize) {
5100 query["PageSize"] = request.PageSize
5101 }
5102
5103 if !dara.IsNil(request.SearchMode) {
5104 query["SearchMode"] = request.SearchMode
5105 }
5106
5107 if !dara.IsNil(request.StartDate) {
5108 query["StartDate"] = request.StartDate
5109 }
5110
5111 if !dara.IsNil(request.Threshold) {
5112 query["Threshold"] = request.Threshold
5113 }
5114
5115 req := &openapiutil.OpenApiRequest{
5116 Query: openapiutil.Query(query),
5117 }
5118 params := &openapiutil.Params{
5119 Action: dara.String("DescribeDomainResolveStatisticsSummary"),
5120 Version: dara.String("2015-01-09"),
5121 Protocol: dara.String("HTTPS"),
5122 Pathname: dara.String("/"),
5123 Method: dara.String("POST"),
5124 AuthType: dara.String("AK"),
5125 Style: dara.String("RPC"),
5126 ReqBodyType: dara.String("formData"),
5127 BodyType: dara.String("json"),
5128 }
5129 _result = &DescribeDomainResolveStatisticsSummaryResponse{}
5130 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5131 if _err != nil {
5132 return _result, _err
5133 }
5134 _err = dara.Convert(_body, &_result)
5135 return _result, _err
5136 }
5137
5138 // Summary:
5139 //
5140 // Queries the real-time statistics on the Domain Name System (DNS) requests for a primary domain name.
5141 //
5142 // Description:
5143 //
5144 // Real-time data is collected per hour.
5145 //
5146 // @param request - DescribeDomainStatisticsRequest
5147 //
5148 // @param runtime - runtime options for this request RuntimeOptions
5149 //
5150 // @return DescribeDomainStatisticsResponse
5151 func DescribeDomainStatisticsWithContext(ctx context.Context, client *Client, request *DescribeDomainStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainStatisticsResponse, _err error) {
5152 if dara.BoolValue(client.EnableValidate) == true {
5153 _err = request.Validate()
5154 if _err != nil {
5155 return _result, _err
5156 }
5157 }
5158 query := map[string]interface{}{}
5159 if !dara.IsNil(request.DomainName) {
5160 query["DomainName"] = request.DomainName
5161 }
5162
5163 if !dara.IsNil(request.DomainType) {
5164 query["DomainType"] = request.DomainType
5165 }
5166
5167 if !dara.IsNil(request.EndDate) {
5168 query["EndDate"] = request.EndDate
5169 }
5170
5171 if !dara.IsNil(request.Lang) {
5172 query["Lang"] = request.Lang
5173 }
5174
5175 if !dara.IsNil(request.StartDate) {
5176 query["StartDate"] = request.StartDate
5177 }
5178
5179 req := &openapiutil.OpenApiRequest{
5180 Query: openapiutil.Query(query),
5181 }
5182 params := &openapiutil.Params{
5183 Action: dara.String("DescribeDomainStatistics"),
5184 Version: dara.String("2015-01-09"),
5185 Protocol: dara.String("HTTPS"),
5186 Pathname: dara.String("/"),
5187 Method: dara.String("POST"),
5188 AuthType: dara.String("AK"),
5189 Style: dara.String("RPC"),
5190 ReqBodyType: dara.String("formData"),
5191 BodyType: dara.String("json"),
5192 }
5193 _result = &DescribeDomainStatisticsResponse{}
5194 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5195 if _err != nil {
5196 return _result, _err
5197 }
5198 _err = dara.Convert(_body, &_result)
5199 return _result, _err
5200 }
5201
5202 // Summary:
5203 //
5204 // Calls the DescribeDomainStatisticsSummary operation to obtain the query volume of all paid domain names under your account.
5205 //
5206 // @param request - DescribeDomainStatisticsSummaryRequest
5207 //
5208 // @param runtime - runtime options for this request RuntimeOptions
5209 //
5210 // @return DescribeDomainStatisticsSummaryResponse
5211 func DescribeDomainStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeDomainStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainStatisticsSummaryResponse, _err error) {
5212 if dara.BoolValue(client.EnableValidate) == true {
5213 _err = request.Validate()
5214 if _err != nil {
5215 return _result, _err
5216 }
5217 }
5218 query := map[string]interface{}{}
5219 if !dara.IsNil(request.EndDate) {
5220 query["EndDate"] = request.EndDate
5221 }
5222
5223 if !dara.IsNil(request.Keyword) {
5224 query["Keyword"] = request.Keyword
5225 }
5226
5227 if !dara.IsNil(request.Lang) {
5228 query["Lang"] = request.Lang
5229 }
5230
5231 if !dara.IsNil(request.PageNumber) {
5232 query["PageNumber"] = request.PageNumber
5233 }
5234
5235 if !dara.IsNil(request.PageSize) {
5236 query["PageSize"] = request.PageSize
5237 }
5238
5239 if !dara.IsNil(request.SearchMode) {
5240 query["SearchMode"] = request.SearchMode
5241 }
5242
5243 if !dara.IsNil(request.StartDate) {
5244 query["StartDate"] = request.StartDate
5245 }
5246
5247 if !dara.IsNil(request.Threshold) {
5248 query["Threshold"] = request.Threshold
5249 }
5250
5251 req := &openapiutil.OpenApiRequest{
5252 Query: openapiutil.Query(query),
5253 }
5254 params := &openapiutil.Params{
5255 Action: dara.String("DescribeDomainStatisticsSummary"),
5256 Version: dara.String("2015-01-09"),
5257 Protocol: dara.String("HTTPS"),
5258 Pathname: dara.String("/"),
5259 Method: dara.String("POST"),
5260 AuthType: dara.String("AK"),
5261 Style: dara.String("RPC"),
5262 ReqBodyType: dara.String("formData"),
5263 BodyType: dara.String("json"),
5264 }
5265 _result = &DescribeDomainStatisticsSummaryResponse{}
5266 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5267 if _err != nil {
5268 return _result, _err
5269 }
5270 _err = dara.Convert(_body, &_result)
5271 return _result, _err
5272 }
5273
5274 // Summary:
5275 //
5276 // Calls the DescribeDomains operation to query domain names of a user based on input parameters.
5277 //
5278 // Description:
5279 //
5280 // You can specify the PageNumber and PageSize parameters to query domain names.
5281 //
5282 // - You can specify the KeyWord parameter to query domain names that contain the specified keyword.
5283 //
5284 // - By default, the domain names in a list are sorted in descending order of the time they were added.
5285 //
5286 // - You can specify the GroupId parameter. If you do not specify this parameter, all domain names are queried by default.
5287 //
5288 // @param request - DescribeDomainsRequest
5289 //
5290 // @param runtime - runtime options for this request RuntimeOptions
5291 //
5292 // @return DescribeDomainsResponse
5293 func DescribeDomainsWithContext(ctx context.Context, client *Client, request *DescribeDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeDomainsResponse, _err error) {
5294 if dara.BoolValue(client.EnableValidate) == true {
5295 _err = request.Validate()
5296 if _err != nil {
5297 return _result, _err
5298 }
5299 }
5300 query := map[string]interface{}{}
5301 if !dara.IsNil(request.GroupId) {
5302 query["GroupId"] = request.GroupId
5303 }
5304
5305 if !dara.IsNil(request.KeyWord) {
5306 query["KeyWord"] = request.KeyWord
5307 }
5308
5309 if !dara.IsNil(request.Lang) {
5310 query["Lang"] = request.Lang
5311 }
5312
5313 if !dara.IsNil(request.PageNumber) {
5314 query["PageNumber"] = request.PageNumber
5315 }
5316
5317 if !dara.IsNil(request.PageSize) {
5318 query["PageSize"] = request.PageSize
5319 }
5320
5321 if !dara.IsNil(request.ResourceGroupId) {
5322 query["ResourceGroupId"] = request.ResourceGroupId
5323 }
5324
5325 if !dara.IsNil(request.SearchMode) {
5326 query["SearchMode"] = request.SearchMode
5327 }
5328
5329 if !dara.IsNil(request.Starmark) {
5330 query["Starmark"] = request.Starmark
5331 }
5332
5333 req := &openapiutil.OpenApiRequest{
5334 Query: openapiutil.Query(query),
5335 }
5336 params := &openapiutil.Params{
5337 Action: dara.String("DescribeDomains"),
5338 Version: dara.String("2015-01-09"),
5339 Protocol: dara.String("HTTPS"),
5340 Pathname: dara.String("/"),
5341 Method: dara.String("POST"),
5342 AuthType: dara.String("AK"),
5343 Style: dara.String("RPC"),
5344 ReqBodyType: dara.String("formData"),
5345 BodyType: dara.String("json"),
5346 }
5347 _result = &DescribeDomainsResponse{}
5348 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5349 if _err != nil {
5350 return _result, _err
5351 }
5352 _err = dara.Convert(_body, &_result)
5353 return _result, _err
5354 }
5355
5356 // Summary:
5357 //
5358 // You can call this operation to query the access policies of a Global Traffic Manager (GTM) instance.
5359 //
5360 // @param request - DescribeGtmAccessStrategiesRequest
5361 //
5362 // @param runtime - runtime options for this request RuntimeOptions
5363 //
5364 // @return DescribeGtmAccessStrategiesResponse
5365 func DescribeGtmAccessStrategiesWithContext(ctx context.Context, client *Client, request *DescribeGtmAccessStrategiesRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategiesResponse, _err error) {
5366 if dara.BoolValue(client.EnableValidate) == true {
5367 _err = request.Validate()
5368 if _err != nil {
5369 return _result, _err
5370 }
5371 }
5372 query := map[string]interface{}{}
5373 if !dara.IsNil(request.InstanceId) {
5374 query["InstanceId"] = request.InstanceId
5375 }
5376
5377 if !dara.IsNil(request.Lang) {
5378 query["Lang"] = request.Lang
5379 }
5380
5381 if !dara.IsNil(request.PageNumber) {
5382 query["PageNumber"] = request.PageNumber
5383 }
5384
5385 if !dara.IsNil(request.PageSize) {
5386 query["PageSize"] = request.PageSize
5387 }
5388
5389 req := &openapiutil.OpenApiRequest{
5390 Query: openapiutil.Query(query),
5391 }
5392 params := &openapiutil.Params{
5393 Action: dara.String("DescribeGtmAccessStrategies"),
5394 Version: dara.String("2015-01-09"),
5395 Protocol: dara.String("HTTPS"),
5396 Pathname: dara.String("/"),
5397 Method: dara.String("POST"),
5398 AuthType: dara.String("AK"),
5399 Style: dara.String("RPC"),
5400 ReqBodyType: dara.String("formData"),
5401 BodyType: dara.String("json"),
5402 }
5403 _result = &DescribeGtmAccessStrategiesResponse{}
5404 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5405 if _err != nil {
5406 return _result, _err
5407 }
5408 _err = dara.Convert(_body, &_result)
5409 return _result, _err
5410 }
5411
5412 // Summary:
5413 //
5414 // 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.
5415 //
5416 // @param request - DescribeGtmAccessStrategyRequest
5417 //
5418 // @param runtime - runtime options for this request RuntimeOptions
5419 //
5420 // @return DescribeGtmAccessStrategyResponse
5421 func DescribeGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *DescribeGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategyResponse, _err error) {
5422 if dara.BoolValue(client.EnableValidate) == true {
5423 _err = request.Validate()
5424 if _err != nil {
5425 return _result, _err
5426 }
5427 }
5428 query := map[string]interface{}{}
5429 if !dara.IsNil(request.Lang) {
5430 query["Lang"] = request.Lang
5431 }
5432
5433 if !dara.IsNil(request.StrategyId) {
5434 query["StrategyId"] = request.StrategyId
5435 }
5436
5437 req := &openapiutil.OpenApiRequest{
5438 Query: openapiutil.Query(query),
5439 }
5440 params := &openapiutil.Params{
5441 Action: dara.String("DescribeGtmAccessStrategy"),
5442 Version: dara.String("2015-01-09"),
5443 Protocol: dara.String("HTTPS"),
5444 Pathname: dara.String("/"),
5445 Method: dara.String("POST"),
5446 AuthType: dara.String("AK"),
5447 Style: dara.String("RPC"),
5448 ReqBodyType: dara.String("formData"),
5449 BodyType: dara.String("json"),
5450 }
5451 _result = &DescribeGtmAccessStrategyResponse{}
5452 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5453 if _err != nil {
5454 return _result, _err
5455 }
5456 _err = dara.Convert(_body, &_result)
5457 return _result, _err
5458 }
5459
5460 // Summary:
5461 //
5462 // Queries the configuration items that can be set for an access policy.
5463 //
5464 // @param request - DescribeGtmAccessStrategyAvailableConfigRequest
5465 //
5466 // @param runtime - runtime options for this request RuntimeOptions
5467 //
5468 // @return DescribeGtmAccessStrategyAvailableConfigResponse
5469 func DescribeGtmAccessStrategyAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeGtmAccessStrategyAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAccessStrategyAvailableConfigResponse, _err error) {
5470 if dara.BoolValue(client.EnableValidate) == true {
5471 _err = request.Validate()
5472 if _err != nil {
5473 return _result, _err
5474 }
5475 }
5476 query := map[string]interface{}{}
5477 if !dara.IsNil(request.InstanceId) {
5478 query["InstanceId"] = request.InstanceId
5479 }
5480
5481 if !dara.IsNil(request.Lang) {
5482 query["Lang"] = request.Lang
5483 }
5484
5485 req := &openapiutil.OpenApiRequest{
5486 Query: openapiutil.Query(query),
5487 }
5488 params := &openapiutil.Params{
5489 Action: dara.String("DescribeGtmAccessStrategyAvailableConfig"),
5490 Version: dara.String("2015-01-09"),
5491 Protocol: dara.String("HTTPS"),
5492 Pathname: dara.String("/"),
5493 Method: dara.String("POST"),
5494 AuthType: dara.String("AK"),
5495 Style: dara.String("RPC"),
5496 ReqBodyType: dara.String("formData"),
5497 BodyType: dara.String("json"),
5498 }
5499 _result = &DescribeGtmAccessStrategyAvailableConfigResponse{}
5500 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5501 if _err != nil {
5502 return _result, _err
5503 }
5504 _err = dara.Convert(_body, &_result)
5505 return _result, _err
5506 }
5507
5508 // @param request - DescribeGtmAvailableAlertGroupRequest
5509 //
5510 // @param runtime - runtime options for this request RuntimeOptions
5511 //
5512 // @return DescribeGtmAvailableAlertGroupResponse
5513 func DescribeGtmAvailableAlertGroupWithContext(ctx context.Context, client *Client, request *DescribeGtmAvailableAlertGroupRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmAvailableAlertGroupResponse, _err error) {
5514 if dara.BoolValue(client.EnableValidate) == true {
5515 _err = request.Validate()
5516 if _err != nil {
5517 return _result, _err
5518 }
5519 }
5520 query := map[string]interface{}{}
5521 if !dara.IsNil(request.Lang) {
5522 query["Lang"] = request.Lang
5523 }
5524
5525 req := &openapiutil.OpenApiRequest{
5526 Query: openapiutil.Query(query),
5527 }
5528 params := &openapiutil.Params{
5529 Action: dara.String("DescribeGtmAvailableAlertGroup"),
5530 Version: dara.String("2015-01-09"),
5531 Protocol: dara.String("HTTPS"),
5532 Pathname: dara.String("/"),
5533 Method: dara.String("POST"),
5534 AuthType: dara.String("AK"),
5535 Style: dara.String("RPC"),
5536 ReqBodyType: dara.String("formData"),
5537 BodyType: dara.String("json"),
5538 }
5539 _result = &DescribeGtmAvailableAlertGroupResponse{}
5540 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5541 if _err != nil {
5542 return _result, _err
5543 }
5544 _err = dara.Convert(_body, &_result)
5545 return _result, _err
5546 }
5547
5548 // Summary:
5549 //
5550 // Queries the details about a Global Traffic Manager (GTM) instance.
5551 //
5552 // @param request - DescribeGtmInstanceRequest
5553 //
5554 // @param runtime - runtime options for this request RuntimeOptions
5555 //
5556 // @return DescribeGtmInstanceResponse
5557 func DescribeGtmInstanceWithContext(ctx context.Context, client *Client, request *DescribeGtmInstanceRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceResponse, _err error) {
5558 if dara.BoolValue(client.EnableValidate) == true {
5559 _err = request.Validate()
5560 if _err != nil {
5561 return _result, _err
5562 }
5563 }
5564 query := map[string]interface{}{}
5565 if !dara.IsNil(request.InstanceId) {
5566 query["InstanceId"] = request.InstanceId
5567 }
5568
5569 if !dara.IsNil(request.Lang) {
5570 query["Lang"] = request.Lang
5571 }
5572
5573 if !dara.IsNil(request.NeedDetailAttributes) {
5574 query["NeedDetailAttributes"] = request.NeedDetailAttributes
5575 }
5576
5577 req := &openapiutil.OpenApiRequest{
5578 Query: openapiutil.Query(query),
5579 }
5580 params := &openapiutil.Params{
5581 Action: dara.String("DescribeGtmInstance"),
5582 Version: dara.String("2015-01-09"),
5583 Protocol: dara.String("HTTPS"),
5584 Pathname: dara.String("/"),
5585 Method: dara.String("POST"),
5586 AuthType: dara.String("AK"),
5587 Style: dara.String("RPC"),
5588 ReqBodyType: dara.String("formData"),
5589 BodyType: dara.String("json"),
5590 }
5591 _result = &DescribeGtmInstanceResponse{}
5592 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5593 if _err != nil {
5594 return _result, _err
5595 }
5596 _err = dara.Convert(_body, &_result)
5597 return _result, _err
5598 }
5599
5600 // Summary:
5601 //
5602 // You can call this operation to query the details about an address pool of a Global Traffic Manager (GTM) instance.
5603 //
5604 // @param request - DescribeGtmInstanceAddressPoolRequest
5605 //
5606 // @param runtime - runtime options for this request RuntimeOptions
5607 //
5608 // @return DescribeGtmInstanceAddressPoolResponse
5609 func DescribeGtmInstanceAddressPoolWithContext(ctx context.Context, client *Client, request *DescribeGtmInstanceAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceAddressPoolResponse, _err error) {
5610 if dara.BoolValue(client.EnableValidate) == true {
5611 _err = request.Validate()
5612 if _err != nil {
5613 return _result, _err
5614 }
5615 }
5616 query := map[string]interface{}{}
5617 if !dara.IsNil(request.AddrPoolId) {
5618 query["AddrPoolId"] = request.AddrPoolId
5619 }
5620
5621 if !dara.IsNil(request.Lang) {
5622 query["Lang"] = request.Lang
5623 }
5624
5625 req := &openapiutil.OpenApiRequest{
5626 Query: openapiutil.Query(query),
5627 }
5628 params := &openapiutil.Params{
5629 Action: dara.String("DescribeGtmInstanceAddressPool"),
5630 Version: dara.String("2015-01-09"),
5631 Protocol: dara.String("HTTPS"),
5632 Pathname: dara.String("/"),
5633 Method: dara.String("POST"),
5634 AuthType: dara.String("AK"),
5635 Style: dara.String("RPC"),
5636 ReqBodyType: dara.String("formData"),
5637 BodyType: dara.String("json"),
5638 }
5639 _result = &DescribeGtmInstanceAddressPoolResponse{}
5640 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5641 if _err != nil {
5642 return _result, _err
5643 }
5644 _err = dara.Convert(_body, &_result)
5645 return _result, _err
5646 }
5647
5648 // Summary:
5649 //
5650 // You can call this operation to query the address pools of a Global Traffic Manager (GTM) instance.
5651 //
5652 // @param request - DescribeGtmInstanceAddressPoolsRequest
5653 //
5654 // @param runtime - runtime options for this request RuntimeOptions
5655 //
5656 // @return DescribeGtmInstanceAddressPoolsResponse
5657 func DescribeGtmInstanceAddressPoolsWithContext(ctx context.Context, client *Client, request *DescribeGtmInstanceAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceAddressPoolsResponse, _err error) {
5658 if dara.BoolValue(client.EnableValidate) == true {
5659 _err = request.Validate()
5660 if _err != nil {
5661 return _result, _err
5662 }
5663 }
5664 query := map[string]interface{}{}
5665 if !dara.IsNil(request.InstanceId) {
5666 query["InstanceId"] = request.InstanceId
5667 }
5668
5669 if !dara.IsNil(request.Lang) {
5670 query["Lang"] = request.Lang
5671 }
5672
5673 if !dara.IsNil(request.PageNumber) {
5674 query["PageNumber"] = request.PageNumber
5675 }
5676
5677 if !dara.IsNil(request.PageSize) {
5678 query["PageSize"] = request.PageSize
5679 }
5680
5681 req := &openapiutil.OpenApiRequest{
5682 Query: openapiutil.Query(query),
5683 }
5684 params := &openapiutil.Params{
5685 Action: dara.String("DescribeGtmInstanceAddressPools"),
5686 Version: dara.String("2015-01-09"),
5687 Protocol: dara.String("HTTPS"),
5688 Pathname: dara.String("/"),
5689 Method: dara.String("POST"),
5690 AuthType: dara.String("AK"),
5691 Style: dara.String("RPC"),
5692 ReqBodyType: dara.String("formData"),
5693 BodyType: dara.String("json"),
5694 }
5695 _result = &DescribeGtmInstanceAddressPoolsResponse{}
5696 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5697 if _err != nil {
5698 return _result, _err
5699 }
5700 _err = dara.Convert(_body, &_result)
5701 return _result, _err
5702 }
5703
5704 // Summary:
5705 //
5706 // Queries the status of a Global Traffic Manager (GTM) instance.
5707 //
5708 // @param request - DescribeGtmInstanceStatusRequest
5709 //
5710 // @param runtime - runtime options for this request RuntimeOptions
5711 //
5712 // @return DescribeGtmInstanceStatusResponse
5713 func DescribeGtmInstanceStatusWithContext(ctx context.Context, client *Client, request *DescribeGtmInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceStatusResponse, _err error) {
5714 if dara.BoolValue(client.EnableValidate) == true {
5715 _err = request.Validate()
5716 if _err != nil {
5717 return _result, _err
5718 }
5719 }
5720 query := map[string]interface{}{}
5721 if !dara.IsNil(request.InstanceId) {
5722 query["InstanceId"] = request.InstanceId
5723 }
5724
5725 if !dara.IsNil(request.Lang) {
5726 query["Lang"] = request.Lang
5727 }
5728
5729 req := &openapiutil.OpenApiRequest{
5730 Query: openapiutil.Query(query),
5731 }
5732 params := &openapiutil.Params{
5733 Action: dara.String("DescribeGtmInstanceStatus"),
5734 Version: dara.String("2015-01-09"),
5735 Protocol: dara.String("HTTPS"),
5736 Pathname: dara.String("/"),
5737 Method: dara.String("POST"),
5738 AuthType: dara.String("AK"),
5739 Style: dara.String("RPC"),
5740 ReqBodyType: dara.String("formData"),
5741 BodyType: dara.String("json"),
5742 }
5743 _result = &DescribeGtmInstanceStatusResponse{}
5744 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5745 if _err != nil {
5746 return _result, _err
5747 }
5748 _err = dara.Convert(_body, &_result)
5749 return _result, _err
5750 }
5751
5752 // @param request - DescribeGtmInstanceSystemCnameRequest
5753 //
5754 // @param runtime - runtime options for this request RuntimeOptions
5755 //
5756 // @return DescribeGtmInstanceSystemCnameResponse
5757 func DescribeGtmInstanceSystemCnameWithContext(ctx context.Context, client *Client, request *DescribeGtmInstanceSystemCnameRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstanceSystemCnameResponse, _err error) {
5758 if dara.BoolValue(client.EnableValidate) == true {
5759 _err = request.Validate()
5760 if _err != nil {
5761 return _result, _err
5762 }
5763 }
5764 query := map[string]interface{}{}
5765 if !dara.IsNil(request.InstanceId) {
5766 query["InstanceId"] = request.InstanceId
5767 }
5768
5769 if !dara.IsNil(request.Lang) {
5770 query["Lang"] = request.Lang
5771 }
5772
5773 req := &openapiutil.OpenApiRequest{
5774 Query: openapiutil.Query(query),
5775 }
5776 params := &openapiutil.Params{
5777 Action: dara.String("DescribeGtmInstanceSystemCname"),
5778 Version: dara.String("2015-01-09"),
5779 Protocol: dara.String("HTTPS"),
5780 Pathname: dara.String("/"),
5781 Method: dara.String("POST"),
5782 AuthType: dara.String("AK"),
5783 Style: dara.String("RPC"),
5784 ReqBodyType: dara.String("formData"),
5785 BodyType: dara.String("json"),
5786 }
5787 _result = &DescribeGtmInstanceSystemCnameResponse{}
5788 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5789 if _err != nil {
5790 return _result, _err
5791 }
5792 _err = dara.Convert(_body, &_result)
5793 return _result, _err
5794 }
5795
5796 // Summary:
5797 //
5798 // Queries the Global Traffic Manager (GTM) instances under your account.
5799 //
5800 // @param request - DescribeGtmInstancesRequest
5801 //
5802 // @param runtime - runtime options for this request RuntimeOptions
5803 //
5804 // @return DescribeGtmInstancesResponse
5805 func DescribeGtmInstancesWithContext(ctx context.Context, client *Client, request *DescribeGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmInstancesResponse, _err error) {
5806 if dara.BoolValue(client.EnableValidate) == true {
5807 _err = request.Validate()
5808 if _err != nil {
5809 return _result, _err
5810 }
5811 }
5812 query := map[string]interface{}{}
5813 if !dara.IsNil(request.Keyword) {
5814 query["Keyword"] = request.Keyword
5815 }
5816
5817 if !dara.IsNil(request.Lang) {
5818 query["Lang"] = request.Lang
5819 }
5820
5821 if !dara.IsNil(request.NeedDetailAttributes) {
5822 query["NeedDetailAttributes"] = request.NeedDetailAttributes
5823 }
5824
5825 if !dara.IsNil(request.PageNumber) {
5826 query["PageNumber"] = request.PageNumber
5827 }
5828
5829 if !dara.IsNil(request.PageSize) {
5830 query["PageSize"] = request.PageSize
5831 }
5832
5833 if !dara.IsNil(request.ResourceGroupId) {
5834 query["ResourceGroupId"] = request.ResourceGroupId
5835 }
5836
5837 req := &openapiutil.OpenApiRequest{
5838 Query: openapiutil.Query(query),
5839 }
5840 params := &openapiutil.Params{
5841 Action: dara.String("DescribeGtmInstances"),
5842 Version: dara.String("2015-01-09"),
5843 Protocol: dara.String("HTTPS"),
5844 Pathname: dara.String("/"),
5845 Method: dara.String("POST"),
5846 AuthType: dara.String("AK"),
5847 Style: dara.String("RPC"),
5848 ReqBodyType: dara.String("formData"),
5849 BodyType: dara.String("json"),
5850 }
5851 _result = &DescribeGtmInstancesResponse{}
5852 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5853 if _err != nil {
5854 return _result, _err
5855 }
5856 _err = dara.Convert(_body, &_result)
5857 return _result, _err
5858 }
5859
5860 // Summary:
5861 //
5862 // You can call this operation to query logs of a Global Traffic Manager (GTM) instance.
5863 //
5864 // @param request - DescribeGtmLogsRequest
5865 //
5866 // @param runtime - runtime options for this request RuntimeOptions
5867 //
5868 // @return DescribeGtmLogsResponse
5869 func DescribeGtmLogsWithContext(ctx context.Context, client *Client, request *DescribeGtmLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmLogsResponse, _err error) {
5870 if dara.BoolValue(client.EnableValidate) == true {
5871 _err = request.Validate()
5872 if _err != nil {
5873 return _result, _err
5874 }
5875 }
5876 query := map[string]interface{}{}
5877 if !dara.IsNil(request.EndTimestamp) {
5878 query["EndTimestamp"] = request.EndTimestamp
5879 }
5880
5881 if !dara.IsNil(request.InstanceId) {
5882 query["InstanceId"] = request.InstanceId
5883 }
5884
5885 if !dara.IsNil(request.Keyword) {
5886 query["Keyword"] = request.Keyword
5887 }
5888
5889 if !dara.IsNil(request.Lang) {
5890 query["Lang"] = request.Lang
5891 }
5892
5893 if !dara.IsNil(request.PageNumber) {
5894 query["PageNumber"] = request.PageNumber
5895 }
5896
5897 if !dara.IsNil(request.PageSize) {
5898 query["PageSize"] = request.PageSize
5899 }
5900
5901 if !dara.IsNil(request.StartTimestamp) {
5902 query["StartTimestamp"] = request.StartTimestamp
5903 }
5904
5905 req := &openapiutil.OpenApiRequest{
5906 Query: openapiutil.Query(query),
5907 }
5908 params := &openapiutil.Params{
5909 Action: dara.String("DescribeGtmLogs"),
5910 Version: dara.String("2015-01-09"),
5911 Protocol: dara.String("HTTPS"),
5912 Pathname: dara.String("/"),
5913 Method: dara.String("POST"),
5914 AuthType: dara.String("AK"),
5915 Style: dara.String("RPC"),
5916 ReqBodyType: dara.String("formData"),
5917 BodyType: dara.String("json"),
5918 }
5919 _result = &DescribeGtmLogsResponse{}
5920 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5921 if _err != nil {
5922 return _result, _err
5923 }
5924 _err = dara.Convert(_body, &_result)
5925 return _result, _err
5926 }
5927
5928 // Summary:
5929 //
5930 // Queries available monitored nodes.
5931 //
5932 // @param request - DescribeGtmMonitorAvailableConfigRequest
5933 //
5934 // @param runtime - runtime options for this request RuntimeOptions
5935 //
5936 // @return DescribeGtmMonitorAvailableConfigResponse
5937 func DescribeGtmMonitorAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeGtmMonitorAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmMonitorAvailableConfigResponse, _err error) {
5938 if dara.BoolValue(client.EnableValidate) == true {
5939 _err = request.Validate()
5940 if _err != nil {
5941 return _result, _err
5942 }
5943 }
5944 query := map[string]interface{}{}
5945 if !dara.IsNil(request.Lang) {
5946 query["Lang"] = request.Lang
5947 }
5948
5949 req := &openapiutil.OpenApiRequest{
5950 Query: openapiutil.Query(query),
5951 }
5952 params := &openapiutil.Params{
5953 Action: dara.String("DescribeGtmMonitorAvailableConfig"),
5954 Version: dara.String("2015-01-09"),
5955 Protocol: dara.String("HTTPS"),
5956 Pathname: dara.String("/"),
5957 Method: dara.String("POST"),
5958 AuthType: dara.String("AK"),
5959 Style: dara.String("RPC"),
5960 ReqBodyType: dara.String("formData"),
5961 BodyType: dara.String("json"),
5962 }
5963 _result = &DescribeGtmMonitorAvailableConfigResponse{}
5964 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5965 if _err != nil {
5966 return _result, _err
5967 }
5968 _err = dara.Convert(_body, &_result)
5969 return _result, _err
5970 }
5971
5972 // Summary:
5973 //
5974 // Queries the health check configuration of an address pool of a Global Traffic Manager (GTM) instance.
5975 //
5976 // @param request - DescribeGtmMonitorConfigRequest
5977 //
5978 // @param runtime - runtime options for this request RuntimeOptions
5979 //
5980 // @return DescribeGtmMonitorConfigResponse
5981 func DescribeGtmMonitorConfigWithContext(ctx context.Context, client *Client, request *DescribeGtmMonitorConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmMonitorConfigResponse, _err error) {
5982 if dara.BoolValue(client.EnableValidate) == true {
5983 _err = request.Validate()
5984 if _err != nil {
5985 return _result, _err
5986 }
5987 }
5988 query := map[string]interface{}{}
5989 if !dara.IsNil(request.Lang) {
5990 query["Lang"] = request.Lang
5991 }
5992
5993 if !dara.IsNil(request.MonitorConfigId) {
5994 query["MonitorConfigId"] = request.MonitorConfigId
5995 }
5996
5997 req := &openapiutil.OpenApiRequest{
5998 Query: openapiutil.Query(query),
5999 }
6000 params := &openapiutil.Params{
6001 Action: dara.String("DescribeGtmMonitorConfig"),
6002 Version: dara.String("2015-01-09"),
6003 Protocol: dara.String("HTTPS"),
6004 Pathname: dara.String("/"),
6005 Method: dara.String("POST"),
6006 AuthType: dara.String("AK"),
6007 Style: dara.String("RPC"),
6008 ReqBodyType: dara.String("formData"),
6009 BodyType: dara.String("json"),
6010 }
6011 _result = &DescribeGtmMonitorConfigResponse{}
6012 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6013 if _err != nil {
6014 return _result, _err
6015 }
6016 _err = dara.Convert(_body, &_result)
6017 return _result, _err
6018 }
6019
6020 // Summary:
6021 //
6022 // Queries the details of a disaster recovery plan.
6023 //
6024 // @param request - DescribeGtmRecoveryPlanRequest
6025 //
6026 // @param runtime - runtime options for this request RuntimeOptions
6027 //
6028 // @return DescribeGtmRecoveryPlanResponse
6029 func DescribeGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *DescribeGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlanResponse, _err error) {
6030 if dara.BoolValue(client.EnableValidate) == true {
6031 _err = request.Validate()
6032 if _err != nil {
6033 return _result, _err
6034 }
6035 }
6036 query := map[string]interface{}{}
6037 if !dara.IsNil(request.Lang) {
6038 query["Lang"] = request.Lang
6039 }
6040
6041 if !dara.IsNil(request.RecoveryPlanId) {
6042 query["RecoveryPlanId"] = request.RecoveryPlanId
6043 }
6044
6045 req := &openapiutil.OpenApiRequest{
6046 Query: openapiutil.Query(query),
6047 }
6048 params := &openapiutil.Params{
6049 Action: dara.String("DescribeGtmRecoveryPlan"),
6050 Version: dara.String("2015-01-09"),
6051 Protocol: dara.String("HTTPS"),
6052 Pathname: dara.String("/"),
6053 Method: dara.String("POST"),
6054 AuthType: dara.String("AK"),
6055 Style: dara.String("RPC"),
6056 ReqBodyType: dara.String("formData"),
6057 BodyType: dara.String("json"),
6058 }
6059 _result = &DescribeGtmRecoveryPlanResponse{}
6060 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6061 if _err != nil {
6062 return _result, _err
6063 }
6064 _err = dara.Convert(_body, &_result)
6065 return _result, _err
6066 }
6067
6068 // Summary:
6069 //
6070 // Queries the configuration items that can be set for a disaster recovery plan.
6071 //
6072 // @param request - DescribeGtmRecoveryPlanAvailableConfigRequest
6073 //
6074 // @param runtime - runtime options for this request RuntimeOptions
6075 //
6076 // @return DescribeGtmRecoveryPlanAvailableConfigResponse
6077 func DescribeGtmRecoveryPlanAvailableConfigWithContext(ctx context.Context, client *Client, request *DescribeGtmRecoveryPlanAvailableConfigRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlanAvailableConfigResponse, _err error) {
6078 if dara.BoolValue(client.EnableValidate) == true {
6079 _err = request.Validate()
6080 if _err != nil {
6081 return _result, _err
6082 }
6083 }
6084 query := map[string]interface{}{}
6085 if !dara.IsNil(request.Lang) {
6086 query["Lang"] = request.Lang
6087 }
6088
6089 req := &openapiutil.OpenApiRequest{
6090 Query: openapiutil.Query(query),
6091 }
6092 params := &openapiutil.Params{
6093 Action: dara.String("DescribeGtmRecoveryPlanAvailableConfig"),
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 = &DescribeGtmRecoveryPlanAvailableConfigResponse{}
6104 _body, _err := client.CallApiWithCtx(ctx, 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 disaster recovery plans for a Global Traffic Manager (GTM) instance.
6115 //
6116 // @param request - DescribeGtmRecoveryPlansRequest
6117 //
6118 // @param runtime - runtime options for this request RuntimeOptions
6119 //
6120 // @return DescribeGtmRecoveryPlansResponse
6121 func DescribeGtmRecoveryPlansWithContext(ctx context.Context, client *Client, request *DescribeGtmRecoveryPlansRequest, runtime *dara.RuntimeOptions) (_result *DescribeGtmRecoveryPlansResponse, _err error) {
6122 if dara.BoolValue(client.EnableValidate) == true {
6123 _err = request.Validate()
6124 if _err != nil {
6125 return _result, _err
6126 }
6127 }
6128 query := map[string]interface{}{}
6129 if !dara.IsNil(request.Keyword) {
6130 query["Keyword"] = request.Keyword
6131 }
6132
6133 if !dara.IsNil(request.Lang) {
6134 query["Lang"] = request.Lang
6135 }
6136
6137 if !dara.IsNil(request.PageNumber) {
6138 query["PageNumber"] = request.PageNumber
6139 }
6140
6141 if !dara.IsNil(request.PageSize) {
6142 query["PageSize"] = request.PageSize
6143 }
6144
6145 req := &openapiutil.OpenApiRequest{
6146 Query: openapiutil.Query(query),
6147 }
6148 params := &openapiutil.Params{
6149 Action: dara.String("DescribeGtmRecoveryPlans"),
6150 Version: dara.String("2015-01-09"),
6151 Protocol: dara.String("HTTPS"),
6152 Pathname: dara.String("/"),
6153 Method: dara.String("POST"),
6154 AuthType: dara.String("AK"),
6155 Style: dara.String("RPC"),
6156 ReqBodyType: dara.String("formData"),
6157 BodyType: dara.String("json"),
6158 }
6159 _result = &DescribeGtmRecoveryPlansResponse{}
6160 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6161 if _err != nil {
6162 return _result, _err
6163 }
6164 _err = dara.Convert(_body, &_result)
6165 return _result, _err
6166 }
6167
6168 // Summary:
6169 //
6170 // Queries the domain names that are bound to an Alibaba Cloud DNS instance.
6171 //
6172 // @param request - DescribeInstanceDomainsRequest
6173 //
6174 // @param runtime - runtime options for this request RuntimeOptions
6175 //
6176 // @return DescribeInstanceDomainsResponse
6177 func DescribeInstanceDomainsWithContext(ctx context.Context, client *Client, request *DescribeInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeInstanceDomainsResponse, _err error) {
6178 if dara.BoolValue(client.EnableValidate) == true {
6179 _err = request.Validate()
6180 if _err != nil {
6181 return _result, _err
6182 }
6183 }
6184 query := map[string]interface{}{}
6185 if !dara.IsNil(request.InstanceId) {
6186 query["InstanceId"] = request.InstanceId
6187 }
6188
6189 if !dara.IsNil(request.Lang) {
6190 query["Lang"] = request.Lang
6191 }
6192
6193 if !dara.IsNil(request.PageNumber) {
6194 query["PageNumber"] = request.PageNumber
6195 }
6196
6197 if !dara.IsNil(request.PageSize) {
6198 query["PageSize"] = request.PageSize
6199 }
6200
6201 req := &openapiutil.OpenApiRequest{
6202 Query: openapiutil.Query(query),
6203 }
6204 params := &openapiutil.Params{
6205 Action: dara.String("DescribeInstanceDomains"),
6206 Version: dara.String("2015-01-09"),
6207 Protocol: dara.String("HTTPS"),
6208 Pathname: dara.String("/"),
6209 Method: dara.String("POST"),
6210 AuthType: dara.String("AK"),
6211 Style: dara.String("RPC"),
6212 ReqBodyType: dara.String("formData"),
6213 BodyType: dara.String("json"),
6214 }
6215 _result = &DescribeInstanceDomainsResponse{}
6216 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6217 if _err != nil {
6218 return _result, _err
6219 }
6220 _err = dara.Convert(_body, &_result)
6221 return _result, _err
6222 }
6223
6224 // Summary:
6225 //
6226 // 查询解析日志
6227 //
6228 // @param request - DescribeInternetDnsLogsRequest
6229 //
6230 // @param runtime - runtime options for this request RuntimeOptions
6231 //
6232 // @return DescribeInternetDnsLogsResponse
6233 func DescribeInternetDnsLogsWithContext(ctx context.Context, client *Client, request *DescribeInternetDnsLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeInternetDnsLogsResponse, _err error) {
6234 if dara.BoolValue(client.EnableValidate) == true {
6235 _err = request.Validate()
6236 if _err != nil {
6237 return _result, _err
6238 }
6239 }
6240 query := map[string]interface{}{}
6241 if !dara.IsNil(request.AccountId) {
6242 query["AccountId"] = request.AccountId
6243 }
6244
6245 if !dara.IsNil(request.DomainName) {
6246 query["DomainName"] = request.DomainName
6247 }
6248
6249 if !dara.IsNil(request.EndTimestamp) {
6250 query["EndTimestamp"] = request.EndTimestamp
6251 }
6252
6253 if !dara.IsNil(request.Lang) {
6254 query["Lang"] = request.Lang
6255 }
6256
6257 if !dara.IsNil(request.Module) {
6258 query["Module"] = request.Module
6259 }
6260
6261 if !dara.IsNil(request.PageNumber) {
6262 query["PageNumber"] = request.PageNumber
6263 }
6264
6265 if !dara.IsNil(request.PageSize) {
6266 query["PageSize"] = request.PageSize
6267 }
6268
6269 if !dara.IsNil(request.QueryCondition) {
6270 query["QueryCondition"] = request.QueryCondition
6271 }
6272
6273 if !dara.IsNil(request.RecursionProtocolType) {
6274 query["RecursionProtocolType"] = request.RecursionProtocolType
6275 }
6276
6277 if !dara.IsNil(request.StartTimestamp) {
6278 query["StartTimestamp"] = request.StartTimestamp
6279 }
6280
6281 req := &openapiutil.OpenApiRequest{
6282 Query: openapiutil.Query(query),
6283 }
6284 params := &openapiutil.Params{
6285 Action: dara.String("DescribeInternetDnsLogs"),
6286 Version: dara.String("2015-01-09"),
6287 Protocol: dara.String("HTTPS"),
6288 Pathname: dara.String("/"),
6289 Method: dara.String("POST"),
6290 AuthType: dara.String("AK"),
6291 Style: dara.String("RPC"),
6292 ReqBodyType: dara.String("formData"),
6293 BodyType: dara.String("json"),
6294 }
6295 _result = &DescribeInternetDnsLogsResponse{}
6296 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6297 if _err != nil {
6298 return _result, _err
6299 }
6300 _err = dara.Convert(_body, &_result)
6301 return _result, _err
6302 }
6303
6304 // Summary:
6305 //
6306 // 获取缓存刷新套餐包列表
6307 //
6308 // @param request - DescribeIspFlushCacheInstancesRequest
6309 //
6310 // @param runtime - runtime options for this request RuntimeOptions
6311 //
6312 // @return DescribeIspFlushCacheInstancesResponse
6313 func DescribeIspFlushCacheInstancesWithContext(ctx context.Context, client *Client, request *DescribeIspFlushCacheInstancesRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheInstancesResponse, _err error) {
6314 if dara.BoolValue(client.EnableValidate) == true {
6315 _err = request.Validate()
6316 if _err != nil {
6317 return _result, _err
6318 }
6319 }
6320 query := map[string]interface{}{}
6321 if !dara.IsNil(request.Direction) {
6322 query["Direction"] = request.Direction
6323 }
6324
6325 if !dara.IsNil(request.Isp) {
6326 query["Isp"] = request.Isp
6327 }
6328
6329 if !dara.IsNil(request.Keyword) {
6330 query["Keyword"] = request.Keyword
6331 }
6332
6333 if !dara.IsNil(request.Lang) {
6334 query["Lang"] = request.Lang
6335 }
6336
6337 if !dara.IsNil(request.OrderBy) {
6338 query["OrderBy"] = request.OrderBy
6339 }
6340
6341 if !dara.IsNil(request.PageNumber) {
6342 query["PageNumber"] = request.PageNumber
6343 }
6344
6345 if !dara.IsNil(request.PageSize) {
6346 query["PageSize"] = request.PageSize
6347 }
6348
6349 if !dara.IsNil(request.Type) {
6350 query["Type"] = request.Type
6351 }
6352
6353 req := &openapiutil.OpenApiRequest{
6354 Query: openapiutil.Query(query),
6355 }
6356 params := &openapiutil.Params{
6357 Action: dara.String("DescribeIspFlushCacheInstances"),
6358 Version: dara.String("2015-01-09"),
6359 Protocol: dara.String("HTTPS"),
6360 Pathname: dara.String("/"),
6361 Method: dara.String("POST"),
6362 AuthType: dara.String("AK"),
6363 Style: dara.String("RPC"),
6364 ReqBodyType: dara.String("formData"),
6365 BodyType: dara.String("json"),
6366 }
6367 _result = &DescribeIspFlushCacheInstancesResponse{}
6368 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6369 if _err != nil {
6370 return _result, _err
6371 }
6372 _err = dara.Convert(_body, &_result)
6373 return _result, _err
6374 }
6375
6376 // Summary:
6377 //
6378 // 获取剩余可缓存刷新次数
6379 //
6380 // @param request - DescribeIspFlushCacheRemainQuotaRequest
6381 //
6382 // @param runtime - runtime options for this request RuntimeOptions
6383 //
6384 // @return DescribeIspFlushCacheRemainQuotaResponse
6385 func DescribeIspFlushCacheRemainQuotaWithContext(ctx context.Context, client *Client, request *DescribeIspFlushCacheRemainQuotaRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheRemainQuotaResponse, _err error) {
6386 if dara.BoolValue(client.EnableValidate) == true {
6387 _err = request.Validate()
6388 if _err != nil {
6389 return _result, _err
6390 }
6391 }
6392 query := map[string]interface{}{}
6393 if !dara.IsNil(request.Lang) {
6394 query["Lang"] = request.Lang
6395 }
6396
6397 req := &openapiutil.OpenApiRequest{
6398 Query: openapiutil.Query(query),
6399 }
6400 params := &openapiutil.Params{
6401 Action: dara.String("DescribeIspFlushCacheRemainQuota"),
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 = &DescribeIspFlushCacheRemainQuotaResponse{}
6412 _body, _err := client.CallApiWithCtx(ctx, 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 // 获取缓存刷新任务详情
6423 //
6424 // @param request - DescribeIspFlushCacheTaskRequest
6425 //
6426 // @param runtime - runtime options for this request RuntimeOptions
6427 //
6428 // @return DescribeIspFlushCacheTaskResponse
6429 func DescribeIspFlushCacheTaskWithContext(ctx context.Context, client *Client, request *DescribeIspFlushCacheTaskRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheTaskResponse, _err error) {
6430 if dara.BoolValue(client.EnableValidate) == true {
6431 _err = request.Validate()
6432 if _err != nil {
6433 return _result, _err
6434 }
6435 }
6436 query := map[string]interface{}{}
6437 if !dara.IsNil(request.Lang) {
6438 query["Lang"] = request.Lang
6439 }
6440
6441 if !dara.IsNil(request.TaskId) {
6442 query["TaskId"] = request.TaskId
6443 }
6444
6445 req := &openapiutil.OpenApiRequest{
6446 Query: openapiutil.Query(query),
6447 }
6448 params := &openapiutil.Params{
6449 Action: dara.String("DescribeIspFlushCacheTask"),
6450 Version: dara.String("2015-01-09"),
6451 Protocol: dara.String("HTTPS"),
6452 Pathname: dara.String("/"),
6453 Method: dara.String("POST"),
6454 AuthType: dara.String("AK"),
6455 Style: dara.String("RPC"),
6456 ReqBodyType: dara.String("formData"),
6457 BodyType: dara.String("json"),
6458 }
6459 _result = &DescribeIspFlushCacheTaskResponse{}
6460 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6461 if _err != nil {
6462 return _result, _err
6463 }
6464 _err = dara.Convert(_body, &_result)
6465 return _result, _err
6466 }
6467
6468 // Summary:
6469 //
6470 // 获取缓存刷新任务列表
6471 //
6472 // @param request - DescribeIspFlushCacheTasksRequest
6473 //
6474 // @param runtime - runtime options for this request RuntimeOptions
6475 //
6476 // @return DescribeIspFlushCacheTasksResponse
6477 func DescribeIspFlushCacheTasksWithContext(ctx context.Context, client *Client, request *DescribeIspFlushCacheTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribeIspFlushCacheTasksResponse, _err error) {
6478 if dara.BoolValue(client.EnableValidate) == true {
6479 _err = request.Validate()
6480 if _err != nil {
6481 return _result, _err
6482 }
6483 }
6484 query := map[string]interface{}{}
6485 if !dara.IsNil(request.Direction) {
6486 query["Direction"] = request.Direction
6487 }
6488
6489 if !dara.IsNil(request.DomainName) {
6490 query["DomainName"] = request.DomainName
6491 }
6492
6493 if !dara.IsNil(request.InstanceId) {
6494 query["InstanceId"] = request.InstanceId
6495 }
6496
6497 if !dara.IsNil(request.Isp) {
6498 query["Isp"] = request.Isp
6499 }
6500
6501 if !dara.IsNil(request.Lang) {
6502 query["Lang"] = request.Lang
6503 }
6504
6505 if !dara.IsNil(request.OrderBy) {
6506 query["OrderBy"] = request.OrderBy
6507 }
6508
6509 if !dara.IsNil(request.PageNumber) {
6510 query["PageNumber"] = request.PageNumber
6511 }
6512
6513 if !dara.IsNil(request.PageSize) {
6514 query["PageSize"] = request.PageSize
6515 }
6516
6517 req := &openapiutil.OpenApiRequest{
6518 Query: openapiutil.Query(query),
6519 }
6520 params := &openapiutil.Params{
6521 Action: dara.String("DescribeIspFlushCacheTasks"),
6522 Version: dara.String("2015-01-09"),
6523 Protocol: dara.String("HTTPS"),
6524 Pathname: dara.String("/"),
6525 Method: dara.String("POST"),
6526 AuthType: dara.String("AK"),
6527 Style: dara.String("RPC"),
6528 ReqBodyType: dara.String("formData"),
6529 BodyType: dara.String("json"),
6530 }
6531 _result = &DescribeIspFlushCacheTasksResponse{}
6532 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6533 if _err != nil {
6534 return _result, _err
6535 }
6536 _err = dara.Convert(_body, &_result)
6537 return _result, _err
6538 }
6539
6540 // Summary:
6541 //
6542 // 获取公共DNS用户数据概览
6543 //
6544 // @param request - DescribePdnsAccountSummaryRequest
6545 //
6546 // @param runtime - runtime options for this request RuntimeOptions
6547 //
6548 // @return DescribePdnsAccountSummaryResponse
6549 func DescribePdnsAccountSummaryWithContext(ctx context.Context, client *Client, request *DescribePdnsAccountSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAccountSummaryResponse, _err error) {
6550 if dara.BoolValue(client.EnableValidate) == true {
6551 _err = request.Validate()
6552 if _err != nil {
6553 return _result, _err
6554 }
6555 }
6556 query := map[string]interface{}{}
6557 if !dara.IsNil(request.EndDate) {
6558 query["EndDate"] = request.EndDate
6559 }
6560
6561 if !dara.IsNil(request.Lang) {
6562 query["Lang"] = request.Lang
6563 }
6564
6565 if !dara.IsNil(request.StartDate) {
6566 query["StartDate"] = request.StartDate
6567 }
6568
6569 req := &openapiutil.OpenApiRequest{
6570 Query: openapiutil.Query(query),
6571 }
6572 params := &openapiutil.Params{
6573 Action: dara.String("DescribePdnsAccountSummary"),
6574 Version: dara.String("2015-01-09"),
6575 Protocol: dara.String("HTTPS"),
6576 Pathname: dara.String("/"),
6577 Method: dara.String("POST"),
6578 AuthType: dara.String("AK"),
6579 Style: dara.String("RPC"),
6580 ReqBodyType: dara.String("formData"),
6581 BodyType: dara.String("json"),
6582 }
6583 _result = &DescribePdnsAccountSummaryResponse{}
6584 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6585 if _err != nil {
6586 return _result, _err
6587 }
6588 _err = dara.Convert(_body, &_result)
6589 return _result, _err
6590 }
6591
6592 // Summary:
6593 //
6594 // 获取公共DNS AppKey 详情
6595 //
6596 // @param request - DescribePdnsAppKeyRequest
6597 //
6598 // @param runtime - runtime options for this request RuntimeOptions
6599 //
6600 // @return DescribePdnsAppKeyResponse
6601 func DescribePdnsAppKeyWithContext(ctx context.Context, client *Client, request *DescribePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAppKeyResponse, _err error) {
6602 if dara.BoolValue(client.EnableValidate) == true {
6603 _err = request.Validate()
6604 if _err != nil {
6605 return _result, _err
6606 }
6607 }
6608 query := map[string]interface{}{}
6609 if !dara.IsNil(request.AppKeyId) {
6610 query["AppKeyId"] = request.AppKeyId
6611 }
6612
6613 if !dara.IsNil(request.AuthCode) {
6614 query["AuthCode"] = request.AuthCode
6615 }
6616
6617 if !dara.IsNil(request.Lang) {
6618 query["Lang"] = request.Lang
6619 }
6620
6621 req := &openapiutil.OpenApiRequest{
6622 Query: openapiutil.Query(query),
6623 }
6624 params := &openapiutil.Params{
6625 Action: dara.String("DescribePdnsAppKey"),
6626 Version: dara.String("2015-01-09"),
6627 Protocol: dara.String("HTTPS"),
6628 Pathname: dara.String("/"),
6629 Method: dara.String("POST"),
6630 AuthType: dara.String("AK"),
6631 Style: dara.String("RPC"),
6632 ReqBodyType: dara.String("formData"),
6633 BodyType: dara.String("json"),
6634 }
6635 _result = &DescribePdnsAppKeyResponse{}
6636 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6637 if _err != nil {
6638 return _result, _err
6639 }
6640 _err = dara.Convert(_body, &_result)
6641 return _result, _err
6642 }
6643
6644 // Summary:
6645 //
6646 // 获取公共DNS AppKey 列表
6647 //
6648 // @param request - DescribePdnsAppKeysRequest
6649 //
6650 // @param runtime - runtime options for this request RuntimeOptions
6651 //
6652 // @return DescribePdnsAppKeysResponse
6653 func DescribePdnsAppKeysWithContext(ctx context.Context, client *Client, request *DescribePdnsAppKeysRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsAppKeysResponse, _err error) {
6654 if dara.BoolValue(client.EnableValidate) == true {
6655 _err = request.Validate()
6656 if _err != nil {
6657 return _result, _err
6658 }
6659 }
6660 query := map[string]interface{}{}
6661 if !dara.IsNil(request.Lang) {
6662 query["Lang"] = request.Lang
6663 }
6664
6665 req := &openapiutil.OpenApiRequest{
6666 Query: openapiutil.Query(query),
6667 }
6668 params := &openapiutil.Params{
6669 Action: dara.String("DescribePdnsAppKeys"),
6670 Version: dara.String("2015-01-09"),
6671 Protocol: dara.String("HTTPS"),
6672 Pathname: dara.String("/"),
6673 Method: dara.String("POST"),
6674 AuthType: dara.String("AK"),
6675 Style: dara.String("RPC"),
6676 ReqBodyType: dara.String("formData"),
6677 BodyType: dara.String("json"),
6678 }
6679 _result = &DescribePdnsAppKeysResponse{}
6680 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6681 if _err != nil {
6682 return _result, _err
6683 }
6684 _err = dara.Convert(_body, &_result)
6685 return _result, _err
6686 }
6687
6688 // Summary:
6689 //
6690 // 获取公共DNS 操作日志列表
6691 //
6692 // @param request - DescribePdnsOperateLogsRequest
6693 //
6694 // @param runtime - runtime options for this request RuntimeOptions
6695 //
6696 // @return DescribePdnsOperateLogsResponse
6697 func DescribePdnsOperateLogsWithContext(ctx context.Context, client *Client, request *DescribePdnsOperateLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsOperateLogsResponse, _err error) {
6698 if dara.BoolValue(client.EnableValidate) == true {
6699 _err = request.Validate()
6700 if _err != nil {
6701 return _result, _err
6702 }
6703 }
6704 query := map[string]interface{}{}
6705 if !dara.IsNil(request.ActionType) {
6706 query["ActionType"] = request.ActionType
6707 }
6708
6709 if !dara.IsNil(request.EndDate) {
6710 query["EndDate"] = request.EndDate
6711 }
6712
6713 if !dara.IsNil(request.Keyword) {
6714 query["Keyword"] = request.Keyword
6715 }
6716
6717 if !dara.IsNil(request.Lang) {
6718 query["Lang"] = request.Lang
6719 }
6720
6721 if !dara.IsNil(request.PageNumber) {
6722 query["PageNumber"] = request.PageNumber
6723 }
6724
6725 if !dara.IsNil(request.PageSize) {
6726 query["PageSize"] = request.PageSize
6727 }
6728
6729 if !dara.IsNil(request.ResourceType) {
6730 query["ResourceType"] = request.ResourceType
6731 }
6732
6733 if !dara.IsNil(request.StartDate) {
6734 query["StartDate"] = request.StartDate
6735 }
6736
6737 req := &openapiutil.OpenApiRequest{
6738 Query: openapiutil.Query(query),
6739 }
6740 params := &openapiutil.Params{
6741 Action: dara.String("DescribePdnsOperateLogs"),
6742 Version: dara.String("2015-01-09"),
6743 Protocol: dara.String("HTTPS"),
6744 Pathname: dara.String("/"),
6745 Method: dara.String("POST"),
6746 AuthType: dara.String("AK"),
6747 Style: dara.String("RPC"),
6748 ReqBodyType: dara.String("formData"),
6749 BodyType: dara.String("json"),
6750 }
6751 _result = &DescribePdnsOperateLogsResponse{}
6752 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6753 if _err != nil {
6754 return _result, _err
6755 }
6756 _err = dara.Convert(_body, &_result)
6757 return _result, _err
6758 }
6759
6760 // Summary:
6761 //
6762 // Queries the statistics on requests for Alibaba Cloud Public DNS.
6763 //
6764 // @param request - DescribePdnsRequestStatisticRequest
6765 //
6766 // @param runtime - runtime options for this request RuntimeOptions
6767 //
6768 // @return DescribePdnsRequestStatisticResponse
6769 func DescribePdnsRequestStatisticWithContext(ctx context.Context, client *Client, request *DescribePdnsRequestStatisticRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsRequestStatisticResponse, _err error) {
6770 if dara.BoolValue(client.EnableValidate) == true {
6771 _err = request.Validate()
6772 if _err != nil {
6773 return _result, _err
6774 }
6775 }
6776 query := map[string]interface{}{}
6777 if !dara.IsNil(request.DomainName) {
6778 query["DomainName"] = request.DomainName
6779 }
6780
6781 if !dara.IsNil(request.EndDate) {
6782 query["EndDate"] = request.EndDate
6783 }
6784
6785 if !dara.IsNil(request.Lang) {
6786 query["Lang"] = request.Lang
6787 }
6788
6789 if !dara.IsNil(request.StartDate) {
6790 query["StartDate"] = request.StartDate
6791 }
6792
6793 if !dara.IsNil(request.SubDomain) {
6794 query["SubDomain"] = request.SubDomain
6795 }
6796
6797 if !dara.IsNil(request.Type) {
6798 query["Type"] = request.Type
6799 }
6800
6801 req := &openapiutil.OpenApiRequest{
6802 Query: openapiutil.Query(query),
6803 }
6804 params := &openapiutil.Params{
6805 Action: dara.String("DescribePdnsRequestStatistic"),
6806 Version: dara.String("2015-01-09"),
6807 Protocol: dara.String("HTTPS"),
6808 Pathname: dara.String("/"),
6809 Method: dara.String("POST"),
6810 AuthType: dara.String("AK"),
6811 Style: dara.String("RPC"),
6812 ReqBodyType: dara.String("formData"),
6813 BodyType: dara.String("json"),
6814 }
6815 _result = &DescribePdnsRequestStatisticResponse{}
6816 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6817 if _err != nil {
6818 return _result, _err
6819 }
6820 _err = dara.Convert(_body, &_result)
6821 return _result, _err
6822 }
6823
6824 // Summary:
6825 //
6826 // Queries a list of statistics on requests for Alibaba Cloud Public DNS.
6827 //
6828 // @param request - DescribePdnsRequestStatisticsRequest
6829 //
6830 // @param runtime - runtime options for this request RuntimeOptions
6831 //
6832 // @return DescribePdnsRequestStatisticsResponse
6833 func DescribePdnsRequestStatisticsWithContext(ctx context.Context, client *Client, request *DescribePdnsRequestStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsRequestStatisticsResponse, _err error) {
6834 if dara.BoolValue(client.EnableValidate) == true {
6835 _err = request.Validate()
6836 if _err != nil {
6837 return _result, _err
6838 }
6839 }
6840 query := map[string]interface{}{}
6841 if !dara.IsNil(request.DomainName) {
6842 query["DomainName"] = request.DomainName
6843 }
6844
6845 if !dara.IsNil(request.EndDate) {
6846 query["EndDate"] = request.EndDate
6847 }
6848
6849 if !dara.IsNil(request.Lang) {
6850 query["Lang"] = request.Lang
6851 }
6852
6853 if !dara.IsNil(request.PageNumber) {
6854 query["PageNumber"] = request.PageNumber
6855 }
6856
6857 if !dara.IsNil(request.PageSize) {
6858 query["PageSize"] = request.PageSize
6859 }
6860
6861 if !dara.IsNil(request.StartDate) {
6862 query["StartDate"] = request.StartDate
6863 }
6864
6865 if !dara.IsNil(request.SubDomain) {
6866 query["SubDomain"] = request.SubDomain
6867 }
6868
6869 if !dara.IsNil(request.Type) {
6870 query["Type"] = request.Type
6871 }
6872
6873 req := &openapiutil.OpenApiRequest{
6874 Query: openapiutil.Query(query),
6875 }
6876 params := &openapiutil.Params{
6877 Action: dara.String("DescribePdnsRequestStatistics"),
6878 Version: dara.String("2015-01-09"),
6879 Protocol: dara.String("HTTPS"),
6880 Pathname: dara.String("/"),
6881 Method: dara.String("POST"),
6882 AuthType: dara.String("AK"),
6883 Style: dara.String("RPC"),
6884 ReqBodyType: dara.String("formData"),
6885 BodyType: dara.String("json"),
6886 }
6887 _result = &DescribePdnsRequestStatisticsResponse{}
6888 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6889 if _err != nil {
6890 return _result, _err
6891 }
6892 _err = dara.Convert(_body, &_result)
6893 return _result, _err
6894 }
6895
6896 // Summary:
6897 //
6898 // 获取公共DNS 威胁日志列表
6899 //
6900 // @param request - DescribePdnsThreatLogsRequest
6901 //
6902 // @param runtime - runtime options for this request RuntimeOptions
6903 //
6904 // @return DescribePdnsThreatLogsResponse
6905 func DescribePdnsThreatLogsWithContext(ctx context.Context, client *Client, request *DescribePdnsThreatLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatLogsResponse, _err error) {
6906 if dara.BoolValue(client.EnableValidate) == true {
6907 _err = request.Validate()
6908 if _err != nil {
6909 return _result, _err
6910 }
6911 }
6912 query := map[string]interface{}{}
6913 if !dara.IsNil(request.EndDate) {
6914 query["EndDate"] = request.EndDate
6915 }
6916
6917 if !dara.IsNil(request.Keyword) {
6918 query["Keyword"] = request.Keyword
6919 }
6920
6921 if !dara.IsNil(request.Lang) {
6922 query["Lang"] = request.Lang
6923 }
6924
6925 if !dara.IsNil(request.PageNumber) {
6926 query["PageNumber"] = request.PageNumber
6927 }
6928
6929 if !dara.IsNil(request.PageSize) {
6930 query["PageSize"] = request.PageSize
6931 }
6932
6933 if !dara.IsNil(request.StartDate) {
6934 query["StartDate"] = request.StartDate
6935 }
6936
6937 if !dara.IsNil(request.ThreatLevel) {
6938 query["ThreatLevel"] = request.ThreatLevel
6939 }
6940
6941 if !dara.IsNil(request.ThreatSourceIp) {
6942 query["ThreatSourceIp"] = request.ThreatSourceIp
6943 }
6944
6945 if !dara.IsNil(request.ThreatType) {
6946 query["ThreatType"] = request.ThreatType
6947 }
6948
6949 req := &openapiutil.OpenApiRequest{
6950 Query: openapiutil.Query(query),
6951 }
6952 params := &openapiutil.Params{
6953 Action: dara.String("DescribePdnsThreatLogs"),
6954 Version: dara.String("2015-01-09"),
6955 Protocol: dara.String("HTTPS"),
6956 Pathname: dara.String("/"),
6957 Method: dara.String("POST"),
6958 AuthType: dara.String("AK"),
6959 Style: dara.String("RPC"),
6960 ReqBodyType: dara.String("formData"),
6961 BodyType: dara.String("json"),
6962 }
6963 _result = &DescribePdnsThreatLogsResponse{}
6964 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6965 if _err != nil {
6966 return _result, _err
6967 }
6968 _err = dara.Convert(_body, &_result)
6969 return _result, _err
6970 }
6971
6972 // Summary:
6973 //
6974 // 获取公共DNS 威胁统计
6975 //
6976 // @param request - DescribePdnsThreatStatisticRequest
6977 //
6978 // @param runtime - runtime options for this request RuntimeOptions
6979 //
6980 // @return DescribePdnsThreatStatisticResponse
6981 func DescribePdnsThreatStatisticWithContext(ctx context.Context, client *Client, request *DescribePdnsThreatStatisticRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatStatisticResponse, _err error) {
6982 if dara.BoolValue(client.EnableValidate) == true {
6983 _err = request.Validate()
6984 if _err != nil {
6985 return _result, _err
6986 }
6987 }
6988 query := map[string]interface{}{}
6989 if !dara.IsNil(request.EndDate) {
6990 query["EndDate"] = request.EndDate
6991 }
6992
6993 if !dara.IsNil(request.Lang) {
6994 query["Lang"] = request.Lang
6995 }
6996
6997 if !dara.IsNil(request.StartDate) {
6998 query["StartDate"] = request.StartDate
6999 }
7000
7001 if !dara.IsNil(request.ThreatSourceIp) {
7002 query["ThreatSourceIp"] = request.ThreatSourceIp
7003 }
7004
7005 req := &openapiutil.OpenApiRequest{
7006 Query: openapiutil.Query(query),
7007 }
7008 params := &openapiutil.Params{
7009 Action: dara.String("DescribePdnsThreatStatistic"),
7010 Version: dara.String("2015-01-09"),
7011 Protocol: dara.String("HTTPS"),
7012 Pathname: dara.String("/"),
7013 Method: dara.String("POST"),
7014 AuthType: dara.String("AK"),
7015 Style: dara.String("RPC"),
7016 ReqBodyType: dara.String("formData"),
7017 BodyType: dara.String("json"),
7018 }
7019 _result = &DescribePdnsThreatStatisticResponse{}
7020 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7021 if _err != nil {
7022 return _result, _err
7023 }
7024 _err = dara.Convert(_body, &_result)
7025 return _result, _err
7026 }
7027
7028 // Summary:
7029 //
7030 // 获取公共DNS 威胁统计列表
7031 //
7032 // @param request - DescribePdnsThreatStatisticsRequest
7033 //
7034 // @param runtime - runtime options for this request RuntimeOptions
7035 //
7036 // @return DescribePdnsThreatStatisticsResponse
7037 func DescribePdnsThreatStatisticsWithContext(ctx context.Context, client *Client, request *DescribePdnsThreatStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsThreatStatisticsResponse, _err error) {
7038 if dara.BoolValue(client.EnableValidate) == true {
7039 _err = request.Validate()
7040 if _err != nil {
7041 return _result, _err
7042 }
7043 }
7044 query := map[string]interface{}{}
7045 if !dara.IsNil(request.Direction) {
7046 query["Direction"] = request.Direction
7047 }
7048
7049 if !dara.IsNil(request.DomainName) {
7050 query["DomainName"] = request.DomainName
7051 }
7052
7053 if !dara.IsNil(request.EndDate) {
7054 query["EndDate"] = request.EndDate
7055 }
7056
7057 if !dara.IsNil(request.Lang) {
7058 query["Lang"] = request.Lang
7059 }
7060
7061 if !dara.IsNil(request.OrderBy) {
7062 query["OrderBy"] = request.OrderBy
7063 }
7064
7065 if !dara.IsNil(request.PageNumber) {
7066 query["PageNumber"] = request.PageNumber
7067 }
7068
7069 if !dara.IsNil(request.PageSize) {
7070 query["PageSize"] = request.PageSize
7071 }
7072
7073 if !dara.IsNil(request.StartDate) {
7074 query["StartDate"] = request.StartDate
7075 }
7076
7077 if !dara.IsNil(request.SubDomain) {
7078 query["SubDomain"] = request.SubDomain
7079 }
7080
7081 if !dara.IsNil(request.ThreatLevel) {
7082 query["ThreatLevel"] = request.ThreatLevel
7083 }
7084
7085 if !dara.IsNil(request.ThreatSourceIp) {
7086 query["ThreatSourceIp"] = request.ThreatSourceIp
7087 }
7088
7089 if !dara.IsNil(request.ThreatType) {
7090 query["ThreatType"] = request.ThreatType
7091 }
7092
7093 if !dara.IsNil(request.Type) {
7094 query["Type"] = request.Type
7095 }
7096
7097 req := &openapiutil.OpenApiRequest{
7098 Query: openapiutil.Query(query),
7099 }
7100 params := &openapiutil.Params{
7101 Action: dara.String("DescribePdnsThreatStatistics"),
7102 Version: dara.String("2015-01-09"),
7103 Protocol: dara.String("HTTPS"),
7104 Pathname: dara.String("/"),
7105 Method: dara.String("POST"),
7106 AuthType: dara.String("AK"),
7107 Style: dara.String("RPC"),
7108 ReqBodyType: dara.String("formData"),
7109 BodyType: dara.String("json"),
7110 }
7111 _result = &DescribePdnsThreatStatisticsResponse{}
7112 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7113 if _err != nil {
7114 return _result, _err
7115 }
7116 _err = dara.Convert(_body, &_result)
7117 return _result, _err
7118 }
7119
7120 // Summary:
7121 //
7122 // 获取公共DNS Udp IP段列表
7123 //
7124 // @param request - DescribePdnsUdpIpSegmentsRequest
7125 //
7126 // @param runtime - runtime options for this request RuntimeOptions
7127 //
7128 // @return DescribePdnsUdpIpSegmentsResponse
7129 func DescribePdnsUdpIpSegmentsWithContext(ctx context.Context, client *Client, request *DescribePdnsUdpIpSegmentsRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsUdpIpSegmentsResponse, _err error) {
7130 if dara.BoolValue(client.EnableValidate) == true {
7131 _err = request.Validate()
7132 if _err != nil {
7133 return _result, _err
7134 }
7135 }
7136 query := map[string]interface{}{}
7137 if !dara.IsNil(request.Lang) {
7138 query["Lang"] = request.Lang
7139 }
7140
7141 if !dara.IsNil(request.PageNumber) {
7142 query["PageNumber"] = request.PageNumber
7143 }
7144
7145 if !dara.IsNil(request.PageSize) {
7146 query["PageSize"] = request.PageSize
7147 }
7148
7149 req := &openapiutil.OpenApiRequest{
7150 Query: openapiutil.Query(query),
7151 }
7152 params := &openapiutil.Params{
7153 Action: dara.String("DescribePdnsUdpIpSegments"),
7154 Version: dara.String("2015-01-09"),
7155 Protocol: dara.String("HTTPS"),
7156 Pathname: dara.String("/"),
7157 Method: dara.String("POST"),
7158 AuthType: dara.String("AK"),
7159 Style: dara.String("RPC"),
7160 ReqBodyType: dara.String("formData"),
7161 BodyType: dara.String("json"),
7162 }
7163 _result = &DescribePdnsUdpIpSegmentsResponse{}
7164 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7165 if _err != nil {
7166 return _result, _err
7167 }
7168 _err = dara.Convert(_body, &_result)
7169 return _result, _err
7170 }
7171
7172 // Summary:
7173 //
7174 // Queries the information about users in Alibaba Cloud Public DNS.
7175 //
7176 // @param request - DescribePdnsUserInfoRequest
7177 //
7178 // @param runtime - runtime options for this request RuntimeOptions
7179 //
7180 // @return DescribePdnsUserInfoResponse
7181 func DescribePdnsUserInfoWithContext(ctx context.Context, client *Client, request *DescribePdnsUserInfoRequest, runtime *dara.RuntimeOptions) (_result *DescribePdnsUserInfoResponse, _err error) {
7182 if dara.BoolValue(client.EnableValidate) == true {
7183 _err = request.Validate()
7184 if _err != nil {
7185 return _result, _err
7186 }
7187 }
7188 query := map[string]interface{}{}
7189 if !dara.IsNil(request.Lang) {
7190 query["Lang"] = request.Lang
7191 }
7192
7193 req := &openapiutil.OpenApiRequest{
7194 Query: openapiutil.Query(query),
7195 }
7196 params := &openapiutil.Params{
7197 Action: dara.String("DescribePdnsUserInfo"),
7198 Version: dara.String("2015-01-09"),
7199 Protocol: dara.String("HTTPS"),
7200 Pathname: dara.String("/"),
7201 Method: dara.String("POST"),
7202 AuthType: dara.String("AK"),
7203 Style: dara.String("RPC"),
7204 ReqBodyType: dara.String("formData"),
7205 BodyType: dara.String("json"),
7206 }
7207 _result = &DescribePdnsUserInfoResponse{}
7208 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7209 if _err != nil {
7210 return _result, _err
7211 }
7212 _err = dara.Convert(_body, &_result)
7213 return _result, _err
7214 }
7215
7216 // Summary:
7217 //
7218 // Queries the operation logs of a domain name based on the specified parameters.
7219 //
7220 // @param request - DescribeRecordLogsRequest
7221 //
7222 // @param runtime - runtime options for this request RuntimeOptions
7223 //
7224 // @return DescribeRecordLogsResponse
7225 func DescribeRecordLogsWithContext(ctx context.Context, client *Client, request *DescribeRecordLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordLogsResponse, _err error) {
7226 if dara.BoolValue(client.EnableValidate) == true {
7227 _err = request.Validate()
7228 if _err != nil {
7229 return _result, _err
7230 }
7231 }
7232 query := map[string]interface{}{}
7233 if !dara.IsNil(request.DomainName) {
7234 query["DomainName"] = request.DomainName
7235 }
7236
7237 if !dara.IsNil(request.KeyWord) {
7238 query["KeyWord"] = request.KeyWord
7239 }
7240
7241 if !dara.IsNil(request.Lang) {
7242 query["Lang"] = request.Lang
7243 }
7244
7245 if !dara.IsNil(request.PageNumber) {
7246 query["PageNumber"] = request.PageNumber
7247 }
7248
7249 if !dara.IsNil(request.PageSize) {
7250 query["PageSize"] = request.PageSize
7251 }
7252
7253 if !dara.IsNil(request.StartDate) {
7254 query["StartDate"] = request.StartDate
7255 }
7256
7257 if !dara.IsNil(request.UserClientIp) {
7258 query["UserClientIp"] = request.UserClientIp
7259 }
7260
7261 if !dara.IsNil(request.EndDate) {
7262 query["endDate"] = request.EndDate
7263 }
7264
7265 req := &openapiutil.OpenApiRequest{
7266 Query: openapiutil.Query(query),
7267 }
7268 params := &openapiutil.Params{
7269 Action: dara.String("DescribeRecordLogs"),
7270 Version: dara.String("2015-01-09"),
7271 Protocol: dara.String("HTTPS"),
7272 Pathname: dara.String("/"),
7273 Method: dara.String("POST"),
7274 AuthType: dara.String("AK"),
7275 Style: dara.String("RPC"),
7276 ReqBodyType: dara.String("formData"),
7277 BodyType: dara.String("json"),
7278 }
7279 _result = &DescribeRecordLogsResponse{}
7280 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7281 if _err != nil {
7282 return _result, _err
7283 }
7284 _err = dara.Convert(_body, &_result)
7285 return _result, _err
7286 }
7287
7288 // Summary:
7289 //
7290 // Queries the number of resolution requests for all subdomain names of a specified domain name.
7291 //
7292 // @param request - DescribeRecordResolveStatisticsSummaryRequest
7293 //
7294 // @param runtime - runtime options for this request RuntimeOptions
7295 //
7296 // @return DescribeRecordResolveStatisticsSummaryResponse
7297 func DescribeRecordResolveStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeRecordResolveStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordResolveStatisticsSummaryResponse, _err error) {
7298 if dara.BoolValue(client.EnableValidate) == true {
7299 _err = request.Validate()
7300 if _err != nil {
7301 return _result, _err
7302 }
7303 }
7304 query := map[string]interface{}{}
7305 if !dara.IsNil(request.Direction) {
7306 query["Direction"] = request.Direction
7307 }
7308
7309 if !dara.IsNil(request.DomainName) {
7310 query["DomainName"] = request.DomainName
7311 }
7312
7313 if !dara.IsNil(request.DomainType) {
7314 query["DomainType"] = request.DomainType
7315 }
7316
7317 if !dara.IsNil(request.EndDate) {
7318 query["EndDate"] = request.EndDate
7319 }
7320
7321 if !dara.IsNil(request.Keyword) {
7322 query["Keyword"] = request.Keyword
7323 }
7324
7325 if !dara.IsNil(request.Lang) {
7326 query["Lang"] = request.Lang
7327 }
7328
7329 if !dara.IsNil(request.PageNumber) {
7330 query["PageNumber"] = request.PageNumber
7331 }
7332
7333 if !dara.IsNil(request.PageSize) {
7334 query["PageSize"] = request.PageSize
7335 }
7336
7337 if !dara.IsNil(request.SearchMode) {
7338 query["SearchMode"] = request.SearchMode
7339 }
7340
7341 if !dara.IsNil(request.StartDate) {
7342 query["StartDate"] = request.StartDate
7343 }
7344
7345 if !dara.IsNil(request.Threshold) {
7346 query["Threshold"] = request.Threshold
7347 }
7348
7349 req := &openapiutil.OpenApiRequest{
7350 Query: openapiutil.Query(query),
7351 }
7352 params := &openapiutil.Params{
7353 Action: dara.String("DescribeRecordResolveStatisticsSummary"),
7354 Version: dara.String("2015-01-09"),
7355 Protocol: dara.String("HTTPS"),
7356 Pathname: dara.String("/"),
7357 Method: dara.String("POST"),
7358 AuthType: dara.String("AK"),
7359 Style: dara.String("RPC"),
7360 ReqBodyType: dara.String("formData"),
7361 BodyType: dara.String("json"),
7362 }
7363 _result = &DescribeRecordResolveStatisticsSummaryResponse{}
7364 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7365 if _err != nil {
7366 return _result, _err
7367 }
7368 _err = dara.Convert(_body, &_result)
7369 return _result, _err
7370 }
7371
7372 // Summary:
7373 //
7374 // Queries the real-time statistics on the Domain Name System (DNS) requests for a subdomain name.
7375 //
7376 // Description:
7377 //
7378 // Real-time data is collected per hour.
7379 //
7380 // @param request - DescribeRecordStatisticsRequest
7381 //
7382 // @param runtime - runtime options for this request RuntimeOptions
7383 //
7384 // @return DescribeRecordStatisticsResponse
7385 func DescribeRecordStatisticsWithContext(ctx context.Context, client *Client, request *DescribeRecordStatisticsRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordStatisticsResponse, _err error) {
7386 if dara.BoolValue(client.EnableValidate) == true {
7387 _err = request.Validate()
7388 if _err != nil {
7389 return _result, _err
7390 }
7391 }
7392 query := map[string]interface{}{}
7393 if !dara.IsNil(request.DomainName) {
7394 query["DomainName"] = request.DomainName
7395 }
7396
7397 if !dara.IsNil(request.DomainType) {
7398 query["DomainType"] = request.DomainType
7399 }
7400
7401 if !dara.IsNil(request.EndDate) {
7402 query["EndDate"] = request.EndDate
7403 }
7404
7405 if !dara.IsNil(request.Lang) {
7406 query["Lang"] = request.Lang
7407 }
7408
7409 if !dara.IsNil(request.Rr) {
7410 query["Rr"] = request.Rr
7411 }
7412
7413 if !dara.IsNil(request.StartDate) {
7414 query["StartDate"] = request.StartDate
7415 }
7416
7417 req := &openapiutil.OpenApiRequest{
7418 Query: openapiutil.Query(query),
7419 }
7420 params := &openapiutil.Params{
7421 Action: dara.String("DescribeRecordStatistics"),
7422 Version: dara.String("2015-01-09"),
7423 Protocol: dara.String("HTTPS"),
7424 Pathname: dara.String("/"),
7425 Method: dara.String("POST"),
7426 AuthType: dara.String("AK"),
7427 Style: dara.String("RPC"),
7428 ReqBodyType: dara.String("formData"),
7429 BodyType: dara.String("json"),
7430 }
7431 _result = &DescribeRecordStatisticsResponse{}
7432 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7433 if _err != nil {
7434 return _result, _err
7435 }
7436 _err = dara.Convert(_body, &_result)
7437 return _result, _err
7438 }
7439
7440 // Summary:
7441 //
7442 // Queries the number of Domain Name System (DNS) requests for all subdomain names of a specified domain name.
7443 //
7444 // @param request - DescribeRecordStatisticsSummaryRequest
7445 //
7446 // @param runtime - runtime options for this request RuntimeOptions
7447 //
7448 // @return DescribeRecordStatisticsSummaryResponse
7449 func DescribeRecordStatisticsSummaryWithContext(ctx context.Context, client *Client, request *DescribeRecordStatisticsSummaryRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecordStatisticsSummaryResponse, _err error) {
7450 if dara.BoolValue(client.EnableValidate) == true {
7451 _err = request.Validate()
7452 if _err != nil {
7453 return _result, _err
7454 }
7455 }
7456 query := map[string]interface{}{}
7457 if !dara.IsNil(request.DomainName) {
7458 query["DomainName"] = request.DomainName
7459 }
7460
7461 if !dara.IsNil(request.DomainType) {
7462 query["DomainType"] = request.DomainType
7463 }
7464
7465 if !dara.IsNil(request.EndDate) {
7466 query["EndDate"] = request.EndDate
7467 }
7468
7469 if !dara.IsNil(request.Keyword) {
7470 query["Keyword"] = request.Keyword
7471 }
7472
7473 if !dara.IsNil(request.Lang) {
7474 query["Lang"] = request.Lang
7475 }
7476
7477 if !dara.IsNil(request.PageNumber) {
7478 query["PageNumber"] = request.PageNumber
7479 }
7480
7481 if !dara.IsNil(request.PageSize) {
7482 query["PageSize"] = request.PageSize
7483 }
7484
7485 if !dara.IsNil(request.SearchMode) {
7486 query["SearchMode"] = request.SearchMode
7487 }
7488
7489 if !dara.IsNil(request.StartDate) {
7490 query["StartDate"] = request.StartDate
7491 }
7492
7493 if !dara.IsNil(request.Threshold) {
7494 query["Threshold"] = request.Threshold
7495 }
7496
7497 req := &openapiutil.OpenApiRequest{
7498 Query: openapiutil.Query(query),
7499 }
7500 params := &openapiutil.Params{
7501 Action: dara.String("DescribeRecordStatisticsSummary"),
7502 Version: dara.String("2015-01-09"),
7503 Protocol: dara.String("HTTPS"),
7504 Pathname: dara.String("/"),
7505 Method: dara.String("POST"),
7506 AuthType: dara.String("AK"),
7507 Style: dara.String("RPC"),
7508 ReqBodyType: dara.String("formData"),
7509 BodyType: dara.String("json"),
7510 }
7511 _result = &DescribeRecordStatisticsSummaryResponse{}
7512 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7513 if _err != nil {
7514 return _result, _err
7515 }
7516 _err = dara.Convert(_body, &_result)
7517 return _result, _err
7518 }
7519
7520 // Summary:
7521 //
7522 // 查询递归解析内置权威解析记录详情
7523 //
7524 // @param request - DescribeRecursionRecordRequest
7525 //
7526 // @param runtime - runtime options for this request RuntimeOptions
7527 //
7528 // @return DescribeRecursionRecordResponse
7529 func DescribeRecursionRecordWithContext(ctx context.Context, client *Client, request *DescribeRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecursionRecordResponse, _err error) {
7530 if dara.BoolValue(client.EnableValidate) == true {
7531 _err = request.Validate()
7532 if _err != nil {
7533 return _result, _err
7534 }
7535 }
7536 query := map[string]interface{}{}
7537 if !dara.IsNil(request.RecordId) {
7538 query["RecordId"] = request.RecordId
7539 }
7540
7541 req := &openapiutil.OpenApiRequest{
7542 Query: openapiutil.Query(query),
7543 }
7544 params := &openapiutil.Params{
7545 Action: dara.String("DescribeRecursionRecord"),
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 = &DescribeRecursionRecordResponse{}
7556 _body, _err := client.CallApiWithCtx(ctx, 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 // 查询递归解析内置权威域名zone详情
7567 //
7568 // @param request - DescribeRecursionZoneRequest
7569 //
7570 // @param runtime - runtime options for this request RuntimeOptions
7571 //
7572 // @return DescribeRecursionZoneResponse
7573 func DescribeRecursionZoneWithContext(ctx context.Context, client *Client, request *DescribeRecursionZoneRequest, runtime *dara.RuntimeOptions) (_result *DescribeRecursionZoneResponse, _err error) {
7574 if dara.BoolValue(client.EnableValidate) == true {
7575 _err = request.Validate()
7576 if _err != nil {
7577 return _result, _err
7578 }
7579 }
7580 query := map[string]interface{}{}
7581 if !dara.IsNil(request.ZoneId) {
7582 query["ZoneId"] = request.ZoneId
7583 }
7584
7585 req := &openapiutil.OpenApiRequest{
7586 Query: openapiutil.Query(query),
7587 }
7588 params := &openapiutil.Params{
7589 Action: dara.String("DescribeRecursionZone"),
7590 Version: dara.String("2015-01-09"),
7591 Protocol: dara.String("HTTPS"),
7592 Pathname: dara.String("/"),
7593 Method: dara.String("POST"),
7594 AuthType: dara.String("AK"),
7595 Style: dara.String("RPC"),
7596 ReqBodyType: dara.String("formData"),
7597 BodyType: dara.String("json"),
7598 }
7599 _result = &DescribeRecursionZoneResponse{}
7600 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7601 if _err != nil {
7602 return _result, _err
7603 }
7604 _err = dara.Convert(_body, &_result)
7605 return _result, _err
7606 }
7607
7608 // Summary:
7609 //
7610 // Queries all Domain Name System (DNS) records of a subdomain name based on the specified parameters.
7611 //
7612 // @param request - DescribeSubDomainRecordsRequest
7613 //
7614 // @param runtime - runtime options for this request RuntimeOptions
7615 //
7616 // @return DescribeSubDomainRecordsResponse
7617 func DescribeSubDomainRecordsWithContext(ctx context.Context, client *Client, request *DescribeSubDomainRecordsRequest, runtime *dara.RuntimeOptions) (_result *DescribeSubDomainRecordsResponse, _err error) {
7618 if dara.BoolValue(client.EnableValidate) == true {
7619 _err = request.Validate()
7620 if _err != nil {
7621 return _result, _err
7622 }
7623 }
7624 query := map[string]interface{}{}
7625 if !dara.IsNil(request.DomainName) {
7626 query["DomainName"] = request.DomainName
7627 }
7628
7629 if !dara.IsNil(request.Lang) {
7630 query["Lang"] = request.Lang
7631 }
7632
7633 if !dara.IsNil(request.Line) {
7634 query["Line"] = request.Line
7635 }
7636
7637 if !dara.IsNil(request.PageNumber) {
7638 query["PageNumber"] = request.PageNumber
7639 }
7640
7641 if !dara.IsNil(request.PageSize) {
7642 query["PageSize"] = request.PageSize
7643 }
7644
7645 if !dara.IsNil(request.SubDomain) {
7646 query["SubDomain"] = request.SubDomain
7647 }
7648
7649 if !dara.IsNil(request.Type) {
7650 query["Type"] = request.Type
7651 }
7652
7653 if !dara.IsNil(request.UserClientIp) {
7654 query["UserClientIp"] = request.UserClientIp
7655 }
7656
7657 req := &openapiutil.OpenApiRequest{
7658 Query: openapiutil.Query(query),
7659 }
7660 params := &openapiutil.Params{
7661 Action: dara.String("DescribeSubDomainRecords"),
7662 Version: dara.String("2015-01-09"),
7663 Protocol: dara.String("HTTPS"),
7664 Pathname: dara.String("/"),
7665 Method: dara.String("POST"),
7666 AuthType: dara.String("AK"),
7667 Style: dara.String("RPC"),
7668 ReqBodyType: dara.String("formData"),
7669 BodyType: dara.String("json"),
7670 }
7671 _result = &DescribeSubDomainRecordsResponse{}
7672 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7673 if _err != nil {
7674 return _result, _err
7675 }
7676 _err = dara.Convert(_body, &_result)
7677 return _result, _err
7678 }
7679
7680 // Summary:
7681 //
7682 // 查询支持的所有线路
7683 //
7684 // @param request - DescribeSupportLinesRequest
7685 //
7686 // @param runtime - runtime options for this request RuntimeOptions
7687 //
7688 // @return DescribeSupportLinesResponse
7689 func DescribeSupportLinesWithContext(ctx context.Context, client *Client, request *DescribeSupportLinesRequest, runtime *dara.RuntimeOptions) (_result *DescribeSupportLinesResponse, _err error) {
7690 if dara.BoolValue(client.EnableValidate) == true {
7691 _err = request.Validate()
7692 if _err != nil {
7693 return _result, _err
7694 }
7695 }
7696 query := map[string]interface{}{}
7697 if !dara.IsNil(request.DomainName) {
7698 query["DomainName"] = request.DomainName
7699 }
7700
7701 if !dara.IsNil(request.Lang) {
7702 query["Lang"] = request.Lang
7703 }
7704
7705 if !dara.IsNil(request.UserClientIp) {
7706 query["UserClientIp"] = request.UserClientIp
7707 }
7708
7709 req := &openapiutil.OpenApiRequest{
7710 Query: openapiutil.Query(query),
7711 }
7712 params := &openapiutil.Params{
7713 Action: dara.String("DescribeSupportLines"),
7714 Version: dara.String("2015-01-09"),
7715 Protocol: dara.String("HTTPS"),
7716 Pathname: dara.String("/"),
7717 Method: dara.String("POST"),
7718 AuthType: dara.String("AK"),
7719 Style: dara.String("RPC"),
7720 ReqBodyType: dara.String("formData"),
7721 BodyType: dara.String("json"),
7722 }
7723 _result = &DescribeSupportLinesResponse{}
7724 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7725 if _err != nil {
7726 return _result, _err
7727 }
7728 _err = dara.Convert(_body, &_result)
7729 return _result, _err
7730 }
7731
7732 // Summary:
7733 //
7734 // Queries existing tags.
7735 //
7736 // @param request - DescribeTagsRequest
7737 //
7738 // @param runtime - runtime options for this request RuntimeOptions
7739 //
7740 // @return DescribeTagsResponse
7741 func DescribeTagsWithContext(ctx context.Context, client *Client, request *DescribeTagsRequest, runtime *dara.RuntimeOptions) (_result *DescribeTagsResponse, _err error) {
7742 if dara.BoolValue(client.EnableValidate) == true {
7743 _err = request.Validate()
7744 if _err != nil {
7745 return _result, _err
7746 }
7747 }
7748 query := map[string]interface{}{}
7749 if !dara.IsNil(request.Lang) {
7750 query["Lang"] = request.Lang
7751 }
7752
7753 if !dara.IsNil(request.PageNumber) {
7754 query["PageNumber"] = request.PageNumber
7755 }
7756
7757 if !dara.IsNil(request.PageSize) {
7758 query["PageSize"] = request.PageSize
7759 }
7760
7761 if !dara.IsNil(request.ResourceType) {
7762 query["ResourceType"] = request.ResourceType
7763 }
7764
7765 req := &openapiutil.OpenApiRequest{
7766 Query: openapiutil.Query(query),
7767 }
7768 params := &openapiutil.Params{
7769 Action: dara.String("DescribeTags"),
7770 Version: dara.String("2015-01-09"),
7771 Protocol: dara.String("HTTPS"),
7772 Pathname: dara.String("/"),
7773 Method: dara.String("POST"),
7774 AuthType: dara.String("AK"),
7775 Style: dara.String("RPC"),
7776 ReqBodyType: dara.String("formData"),
7777 BodyType: dara.String("json"),
7778 }
7779 _result = &DescribeTagsResponse{}
7780 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7781 if _err != nil {
7782 return _result, _err
7783 }
7784 _err = dara.Convert(_body, &_result)
7785 return _result, _err
7786 }
7787
7788 // Summary:
7789 //
7790 // Queries the domain names that were transferred between the current account and another account based on the specified parameters.
7791 //
7792 // @param request - DescribeTransferDomainsRequest
7793 //
7794 // @param runtime - runtime options for this request RuntimeOptions
7795 //
7796 // @return DescribeTransferDomainsResponse
7797 func DescribeTransferDomainsWithContext(ctx context.Context, client *Client, request *DescribeTransferDomainsRequest, runtime *dara.RuntimeOptions) (_result *DescribeTransferDomainsResponse, _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.DomainName) {
7806 query["DomainName"] = request.DomainName
7807 }
7808
7809 if !dara.IsNil(request.FromUserId) {
7810 query["FromUserId"] = request.FromUserId
7811 }
7812
7813 if !dara.IsNil(request.Lang) {
7814 query["Lang"] = request.Lang
7815 }
7816
7817 if !dara.IsNil(request.PageNumber) {
7818 query["PageNumber"] = request.PageNumber
7819 }
7820
7821 if !dara.IsNil(request.PageSize) {
7822 query["PageSize"] = request.PageSize
7823 }
7824
7825 if !dara.IsNil(request.TargetUserId) {
7826 query["TargetUserId"] = request.TargetUserId
7827 }
7828
7829 if !dara.IsNil(request.TransferType) {
7830 query["TransferType"] = request.TransferType
7831 }
7832
7833 req := &openapiutil.OpenApiRequest{
7834 Query: openapiutil.Query(query),
7835 }
7836 params := &openapiutil.Params{
7837 Action: dara.String("DescribeTransferDomains"),
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 = &DescribeTransferDomainsResponse{}
7848 _body, _err := client.CallApiWithCtx(ctx, 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 // Executes a disaster recovery plan.
7859 //
7860 // @param request - ExecuteGtmRecoveryPlanRequest
7861 //
7862 // @param runtime - runtime options for this request RuntimeOptions
7863 //
7864 // @return ExecuteGtmRecoveryPlanResponse
7865 func ExecuteGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *ExecuteGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *ExecuteGtmRecoveryPlanResponse, _err error) {
7866 if dara.BoolValue(client.EnableValidate) == true {
7867 _err = request.Validate()
7868 if _err != nil {
7869 return _result, _err
7870 }
7871 }
7872 query := map[string]interface{}{}
7873 if !dara.IsNil(request.Lang) {
7874 query["Lang"] = request.Lang
7875 }
7876
7877 if !dara.IsNil(request.RecoveryPlanId) {
7878 query["RecoveryPlanId"] = request.RecoveryPlanId
7879 }
7880
7881 req := &openapiutil.OpenApiRequest{
7882 Query: openapiutil.Query(query),
7883 }
7884 params := &openapiutil.Params{
7885 Action: dara.String("ExecuteGtmRecoveryPlan"),
7886 Version: dara.String("2015-01-09"),
7887 Protocol: dara.String("HTTPS"),
7888 Pathname: dara.String("/"),
7889 Method: dara.String("POST"),
7890 AuthType: dara.String("AK"),
7891 Style: dara.String("RPC"),
7892 ReqBodyType: dara.String("formData"),
7893 BodyType: dara.String("json"),
7894 }
7895 _result = &ExecuteGtmRecoveryPlanResponse{}
7896 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7897 if _err != nil {
7898 return _result, _err
7899 }
7900 _err = dara.Convert(_body, &_result)
7901 return _result, _err
7902 }
7903
7904 // Summary:
7905 //
7906 // Queries a primary domain name based on the specified parameters.
7907 //
7908 // Description:
7909 //
7910 // # For more information about the difference between primary domain names and subdomain names, see
7911 //
7912 // [Subdomain levels](https://www.alibabacloud.com/help/zh/faq-detail/39803.htm). For example, if you enter `www.abc.com`, abc.com is obtained.
7913 //
7914 // @param request - GetMainDomainNameRequest
7915 //
7916 // @param runtime - runtime options for this request RuntimeOptions
7917 //
7918 // @return GetMainDomainNameResponse
7919 func GetMainDomainNameWithContext(ctx context.Context, client *Client, request *GetMainDomainNameRequest, runtime *dara.RuntimeOptions) (_result *GetMainDomainNameResponse, _err error) {
7920 if dara.BoolValue(client.EnableValidate) == true {
7921 _err = request.Validate()
7922 if _err != nil {
7923 return _result, _err
7924 }
7925 }
7926 query := map[string]interface{}{}
7927 if !dara.IsNil(request.InputString) {
7928 query["InputString"] = request.InputString
7929 }
7930
7931 if !dara.IsNil(request.Lang) {
7932 query["Lang"] = request.Lang
7933 }
7934
7935 req := &openapiutil.OpenApiRequest{
7936 Query: openapiutil.Query(query),
7937 }
7938 params := &openapiutil.Params{
7939 Action: dara.String("GetMainDomainName"),
7940 Version: dara.String("2015-01-09"),
7941 Protocol: dara.String("HTTPS"),
7942 Pathname: dara.String("/"),
7943 Method: dara.String("POST"),
7944 AuthType: dara.String("AK"),
7945 Style: dara.String("RPC"),
7946 ReqBodyType: dara.String("formData"),
7947 BodyType: dara.String("json"),
7948 }
7949 _result = &GetMainDomainNameResponse{}
7950 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7951 if _err != nil {
7952 return _result, _err
7953 }
7954 _err = dara.Convert(_body, &_result)
7955 return _result, _err
7956 }
7957
7958 // Summary:
7959 //
7960 // 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.
7961 //
7962 // @param request - GetTxtRecordForVerifyRequest
7963 //
7964 // @param runtime - runtime options for this request RuntimeOptions
7965 //
7966 // @return GetTxtRecordForVerifyResponse
7967 func GetTxtRecordForVerifyWithContext(ctx context.Context, client *Client, request *GetTxtRecordForVerifyRequest, runtime *dara.RuntimeOptions) (_result *GetTxtRecordForVerifyResponse, _err error) {
7968 if dara.BoolValue(client.EnableValidate) == true {
7969 _err = request.Validate()
7970 if _err != nil {
7971 return _result, _err
7972 }
7973 }
7974 query := map[string]interface{}{}
7975 if !dara.IsNil(request.DomainName) {
7976 query["DomainName"] = request.DomainName
7977 }
7978
7979 if !dara.IsNil(request.Lang) {
7980 query["Lang"] = request.Lang
7981 }
7982
7983 if !dara.IsNil(request.Type) {
7984 query["Type"] = request.Type
7985 }
7986
7987 req := &openapiutil.OpenApiRequest{
7988 Query: openapiutil.Query(query),
7989 }
7990 params := &openapiutil.Params{
7991 Action: dara.String("GetTxtRecordForVerify"),
7992 Version: dara.String("2015-01-09"),
7993 Protocol: dara.String("HTTPS"),
7994 Pathname: dara.String("/"),
7995 Method: dara.String("POST"),
7996 AuthType: dara.String("AK"),
7997 Style: dara.String("RPC"),
7998 ReqBodyType: dara.String("formData"),
7999 BodyType: dara.String("json"),
8000 }
8001 _result = &GetTxtRecordForVerifyResponse{}
8002 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8003 if _err != nil {
8004 return _result, _err
8005 }
8006 _err = dara.Convert(_body, &_result)
8007 return _result, _err
8008 }
8009
8010 // Summary:
8011 //
8012 // Queries a list of address pools.
8013 //
8014 // @param request - ListCloudGtmAddressPoolsRequest
8015 //
8016 // @param runtime - runtime options for this request RuntimeOptions
8017 //
8018 // @return ListCloudGtmAddressPoolsResponse
8019 func ListCloudGtmAddressPoolsWithContext(ctx context.Context, client *Client, request *ListCloudGtmAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAddressPoolsResponse, _err error) {
8020 if dara.BoolValue(client.EnableValidate) == true {
8021 _err = request.Validate()
8022 if _err != nil {
8023 return _result, _err
8024 }
8025 }
8026 query := map[string]interface{}{}
8027 if !dara.IsNil(request.AcceptLanguage) {
8028 query["AcceptLanguage"] = request.AcceptLanguage
8029 }
8030
8031 if !dara.IsNil(request.AddressPoolName) {
8032 query["AddressPoolName"] = request.AddressPoolName
8033 }
8034
8035 if !dara.IsNil(request.AddressPoolType) {
8036 query["AddressPoolType"] = request.AddressPoolType
8037 }
8038
8039 if !dara.IsNil(request.ClientToken) {
8040 query["ClientToken"] = request.ClientToken
8041 }
8042
8043 if !dara.IsNil(request.EnableStatus) {
8044 query["EnableStatus"] = request.EnableStatus
8045 }
8046
8047 if !dara.IsNil(request.PageNumber) {
8048 query["PageNumber"] = request.PageNumber
8049 }
8050
8051 if !dara.IsNil(request.PageSize) {
8052 query["PageSize"] = request.PageSize
8053 }
8054
8055 if !dara.IsNil(request.Remark) {
8056 query["Remark"] = request.Remark
8057 }
8058
8059 req := &openapiutil.OpenApiRequest{
8060 Query: openapiutil.Query(query),
8061 }
8062 params := &openapiutil.Params{
8063 Action: dara.String("ListCloudGtmAddressPools"),
8064 Version: dara.String("2015-01-09"),
8065 Protocol: dara.String("HTTPS"),
8066 Pathname: dara.String("/"),
8067 Method: dara.String("POST"),
8068 AuthType: dara.String("AK"),
8069 Style: dara.String("RPC"),
8070 ReqBodyType: dara.String("formData"),
8071 BodyType: dara.String("json"),
8072 }
8073 _result = &ListCloudGtmAddressPoolsResponse{}
8074 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8075 if _err != nil {
8076 return _result, _err
8077 }
8078 _err = dara.Convert(_body, &_result)
8079 return _result, _err
8080 }
8081
8082 // Summary:
8083 //
8084 // Queries a list of addresses.
8085 //
8086 // @param request - ListCloudGtmAddressesRequest
8087 //
8088 // @param runtime - runtime options for this request RuntimeOptions
8089 //
8090 // @return ListCloudGtmAddressesResponse
8091 func ListCloudGtmAddressesWithContext(ctx context.Context, client *Client, request *ListCloudGtmAddressesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAddressesResponse, _err error) {
8092 if dara.BoolValue(client.EnableValidate) == true {
8093 _err = request.Validate()
8094 if _err != nil {
8095 return _result, _err
8096 }
8097 }
8098 query := map[string]interface{}{}
8099 if !dara.IsNil(request.AcceptLanguage) {
8100 query["AcceptLanguage"] = request.AcceptLanguage
8101 }
8102
8103 if !dara.IsNil(request.Address) {
8104 query["Address"] = request.Address
8105 }
8106
8107 if !dara.IsNil(request.AddressId) {
8108 query["AddressId"] = request.AddressId
8109 }
8110
8111 if !dara.IsNil(request.ClientToken) {
8112 query["ClientToken"] = request.ClientToken
8113 }
8114
8115 if !dara.IsNil(request.EnableStatus) {
8116 query["EnableStatus"] = request.EnableStatus
8117 }
8118
8119 if !dara.IsNil(request.HealthStatus) {
8120 query["HealthStatus"] = request.HealthStatus
8121 }
8122
8123 if !dara.IsNil(request.MonitorTemplateId) {
8124 query["MonitorTemplateId"] = request.MonitorTemplateId
8125 }
8126
8127 if !dara.IsNil(request.Name) {
8128 query["Name"] = request.Name
8129 }
8130
8131 if !dara.IsNil(request.PageNumber) {
8132 query["PageNumber"] = request.PageNumber
8133 }
8134
8135 if !dara.IsNil(request.PageSize) {
8136 query["PageSize"] = request.PageSize
8137 }
8138
8139 if !dara.IsNil(request.Type) {
8140 query["Type"] = request.Type
8141 }
8142
8143 req := &openapiutil.OpenApiRequest{
8144 Query: openapiutil.Query(query),
8145 }
8146 params := &openapiutil.Params{
8147 Action: dara.String("ListCloudGtmAddresses"),
8148 Version: dara.String("2015-01-09"),
8149 Protocol: dara.String("HTTPS"),
8150 Pathname: dara.String("/"),
8151 Method: dara.String("POST"),
8152 AuthType: dara.String("AK"),
8153 Style: dara.String("RPC"),
8154 ReqBodyType: dara.String("formData"),
8155 BodyType: dara.String("json"),
8156 }
8157 _result = &ListCloudGtmAddressesResponse{}
8158 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8159 if _err != nil {
8160 return _result, _err
8161 }
8162 _err = dara.Convert(_body, &_result)
8163 return _result, _err
8164 }
8165
8166 // @param request - ListCloudGtmAlertLogsRequest
8167 //
8168 // @param runtime - runtime options for this request RuntimeOptions
8169 //
8170 // @return ListCloudGtmAlertLogsResponse
8171 func ListCloudGtmAlertLogsWithContext(ctx context.Context, client *Client, request *ListCloudGtmAlertLogsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAlertLogsResponse, _err error) {
8172 if dara.BoolValue(client.EnableValidate) == true {
8173 _err = request.Validate()
8174 if _err != nil {
8175 return _result, _err
8176 }
8177 }
8178 query := map[string]interface{}{}
8179 if !dara.IsNil(request.ActionType) {
8180 query["ActionType"] = request.ActionType
8181 }
8182
8183 if !dara.IsNil(request.EndTimestamp) {
8184 query["EndTimestamp"] = request.EndTimestamp
8185 }
8186
8187 if !dara.IsNil(request.EntityType) {
8188 query["EntityType"] = request.EntityType
8189 }
8190
8191 if !dara.IsNil(request.Keyword) {
8192 query["Keyword"] = request.Keyword
8193 }
8194
8195 if !dara.IsNil(request.Lang) {
8196 query["Lang"] = request.Lang
8197 }
8198
8199 if !dara.IsNil(request.PageNumber) {
8200 query["PageNumber"] = request.PageNumber
8201 }
8202
8203 if !dara.IsNil(request.PageSize) {
8204 query["PageSize"] = request.PageSize
8205 }
8206
8207 if !dara.IsNil(request.StartTimestamp) {
8208 query["StartTimestamp"] = request.StartTimestamp
8209 }
8210
8211 req := &openapiutil.OpenApiRequest{
8212 Query: openapiutil.Query(query),
8213 }
8214 params := &openapiutil.Params{
8215 Action: dara.String("ListCloudGtmAlertLogs"),
8216 Version: dara.String("2015-01-09"),
8217 Protocol: dara.String("HTTPS"),
8218 Pathname: dara.String("/"),
8219 Method: dara.String("POST"),
8220 AuthType: dara.String("AK"),
8221 Style: dara.String("RPC"),
8222 ReqBodyType: dara.String("formData"),
8223 BodyType: dara.String("json"),
8224 }
8225 _result = &ListCloudGtmAlertLogsResponse{}
8226 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8227 if _err != nil {
8228 return _result, _err
8229 }
8230 _err = dara.Convert(_body, &_result)
8231 return _result, _err
8232 }
8233
8234 // @param request - ListCloudGtmAvailableAlertGroupsRequest
8235 //
8236 // @param runtime - runtime options for this request RuntimeOptions
8237 //
8238 // @return ListCloudGtmAvailableAlertGroupsResponse
8239 func ListCloudGtmAvailableAlertGroupsWithContext(ctx context.Context, client *Client, request *ListCloudGtmAvailableAlertGroupsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmAvailableAlertGroupsResponse, _err error) {
8240 if dara.BoolValue(client.EnableValidate) == true {
8241 _err = request.Validate()
8242 if _err != nil {
8243 return _result, _err
8244 }
8245 }
8246 query := map[string]interface{}{}
8247 if !dara.IsNil(request.AcceptLanguage) {
8248 query["AcceptLanguage"] = request.AcceptLanguage
8249 }
8250
8251 req := &openapiutil.OpenApiRequest{
8252 Query: openapiutil.Query(query),
8253 }
8254 params := &openapiutil.Params{
8255 Action: dara.String("ListCloudGtmAvailableAlertGroups"),
8256 Version: dara.String("2015-01-09"),
8257 Protocol: dara.String("HTTPS"),
8258 Pathname: dara.String("/"),
8259 Method: dara.String("POST"),
8260 AuthType: dara.String("AK"),
8261 Style: dara.String("RPC"),
8262 ReqBodyType: dara.String("formData"),
8263 BodyType: dara.String("json"),
8264 }
8265 _result = &ListCloudGtmAvailableAlertGroupsResponse{}
8266 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8267 if _err != nil {
8268 return _result, _err
8269 }
8270 _err = dara.Convert(_body, &_result)
8271 return _result, _err
8272 }
8273
8274 // Summary:
8275 //
8276 // Queries the configurations of a Global Traffic Manager (GTM) instance, including the information about access domain names and address pools.
8277 //
8278 // @param request - ListCloudGtmInstanceConfigsRequest
8279 //
8280 // @param runtime - runtime options for this request RuntimeOptions
8281 //
8282 // @return ListCloudGtmInstanceConfigsResponse
8283 func ListCloudGtmInstanceConfigsWithContext(ctx context.Context, client *Client, request *ListCloudGtmInstanceConfigsRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmInstanceConfigsResponse, _err error) {
8284 if dara.BoolValue(client.EnableValidate) == true {
8285 _err = request.Validate()
8286 if _err != nil {
8287 return _result, _err
8288 }
8289 }
8290 query := map[string]interface{}{}
8291 if !dara.IsNil(request.AcceptLanguage) {
8292 query["AcceptLanguage"] = request.AcceptLanguage
8293 }
8294
8295 if !dara.IsNil(request.ClientToken) {
8296 query["ClientToken"] = request.ClientToken
8297 }
8298
8299 if !dara.IsNil(request.EnableStatus) {
8300 query["EnableStatus"] = request.EnableStatus
8301 }
8302
8303 if !dara.IsNil(request.InstanceId) {
8304 query["InstanceId"] = request.InstanceId
8305 }
8306
8307 if !dara.IsNil(request.PageNumber) {
8308 query["PageNumber"] = request.PageNumber
8309 }
8310
8311 if !dara.IsNil(request.PageSize) {
8312 query["PageSize"] = request.PageSize
8313 }
8314
8315 if !dara.IsNil(request.Remark) {
8316 query["Remark"] = request.Remark
8317 }
8318
8319 if !dara.IsNil(request.ScheduleDomainName) {
8320 query["ScheduleDomainName"] = request.ScheduleDomainName
8321 }
8322
8323 if !dara.IsNil(request.ScheduleZoneName) {
8324 query["ScheduleZoneName"] = request.ScheduleZoneName
8325 }
8326
8327 req := &openapiutil.OpenApiRequest{
8328 Query: openapiutil.Query(query),
8329 }
8330 params := &openapiutil.Params{
8331 Action: dara.String("ListCloudGtmInstanceConfigs"),
8332 Version: dara.String("2015-01-09"),
8333 Protocol: dara.String("HTTPS"),
8334 Pathname: dara.String("/"),
8335 Method: dara.String("POST"),
8336 AuthType: dara.String("AK"),
8337 Style: dara.String("RPC"),
8338 ReqBodyType: dara.String("formData"),
8339 BodyType: dara.String("json"),
8340 }
8341 _result = &ListCloudGtmInstanceConfigsResponse{}
8342 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8343 if _err != nil {
8344 return _result, _err
8345 }
8346 _err = dara.Convert(_body, &_result)
8347 return _result, _err
8348 }
8349
8350 // Summary:
8351 //
8352 // Queries a list of Global Traffic Manager (GTM) 3.0 instances.
8353 //
8354 // @param request - ListCloudGtmInstancesRequest
8355 //
8356 // @param runtime - runtime options for this request RuntimeOptions
8357 //
8358 // @return ListCloudGtmInstancesResponse
8359 func ListCloudGtmInstancesWithContext(ctx context.Context, client *Client, request *ListCloudGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmInstancesResponse, _err error) {
8360 if dara.BoolValue(client.EnableValidate) == true {
8361 _err = request.Validate()
8362 if _err != nil {
8363 return _result, _err
8364 }
8365 }
8366 query := map[string]interface{}{}
8367 if !dara.IsNil(request.AcceptLanguage) {
8368 query["AcceptLanguage"] = request.AcceptLanguage
8369 }
8370
8371 if !dara.IsNil(request.ChargeType) {
8372 query["ChargeType"] = request.ChargeType
8373 }
8374
8375 if !dara.IsNil(request.ClientToken) {
8376 query["ClientToken"] = request.ClientToken
8377 }
8378
8379 if !dara.IsNil(request.InstanceId) {
8380 query["InstanceId"] = request.InstanceId
8381 }
8382
8383 if !dara.IsNil(request.InstanceName) {
8384 query["InstanceName"] = request.InstanceName
8385 }
8386
8387 if !dara.IsNil(request.PageNumber) {
8388 query["PageNumber"] = request.PageNumber
8389 }
8390
8391 if !dara.IsNil(request.PageSize) {
8392 query["PageSize"] = request.PageSize
8393 }
8394
8395 req := &openapiutil.OpenApiRequest{
8396 Query: openapiutil.Query(query),
8397 }
8398 params := &openapiutil.Params{
8399 Action: dara.String("ListCloudGtmInstances"),
8400 Version: dara.String("2015-01-09"),
8401 Protocol: dara.String("HTTPS"),
8402 Pathname: dara.String("/"),
8403 Method: dara.String("POST"),
8404 AuthType: dara.String("AK"),
8405 Style: dara.String("RPC"),
8406 ReqBodyType: dara.String("formData"),
8407 BodyType: dara.String("json"),
8408 }
8409 _result = &ListCloudGtmInstancesResponse{}
8410 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8411 if _err != nil {
8412 return _result, _err
8413 }
8414 _err = dara.Convert(_body, &_result)
8415 return _result, _err
8416 }
8417
8418 // Summary:
8419 //
8420 // Queries a list of health check nodes.
8421 //
8422 // @param request - ListCloudGtmMonitorNodesRequest
8423 //
8424 // @param runtime - runtime options for this request RuntimeOptions
8425 //
8426 // @return ListCloudGtmMonitorNodesResponse
8427 func ListCloudGtmMonitorNodesWithContext(ctx context.Context, client *Client, request *ListCloudGtmMonitorNodesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmMonitorNodesResponse, _err error) {
8428 if dara.BoolValue(client.EnableValidate) == true {
8429 _err = request.Validate()
8430 if _err != nil {
8431 return _result, _err
8432 }
8433 }
8434 query := map[string]interface{}{}
8435 if !dara.IsNil(request.AcceptLanguage) {
8436 query["AcceptLanguage"] = request.AcceptLanguage
8437 }
8438
8439 req := &openapiutil.OpenApiRequest{
8440 Query: openapiutil.Query(query),
8441 }
8442 params := &openapiutil.Params{
8443 Action: dara.String("ListCloudGtmMonitorNodes"),
8444 Version: dara.String("2015-01-09"),
8445 Protocol: dara.String("HTTPS"),
8446 Pathname: dara.String("/"),
8447 Method: dara.String("POST"),
8448 AuthType: dara.String("AK"),
8449 Style: dara.String("RPC"),
8450 ReqBodyType: dara.String("formData"),
8451 BodyType: dara.String("json"),
8452 }
8453 _result = &ListCloudGtmMonitorNodesResponse{}
8454 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8455 if _err != nil {
8456 return _result, _err
8457 }
8458 _err = dara.Convert(_body, &_result)
8459 return _result, _err
8460 }
8461
8462 // Summary:
8463 //
8464 // Queries a list of health check templates.
8465 //
8466 // @param request - ListCloudGtmMonitorTemplatesRequest
8467 //
8468 // @param runtime - runtime options for this request RuntimeOptions
8469 //
8470 // @return ListCloudGtmMonitorTemplatesResponse
8471 func ListCloudGtmMonitorTemplatesWithContext(ctx context.Context, client *Client, request *ListCloudGtmMonitorTemplatesRequest, runtime *dara.RuntimeOptions) (_result *ListCloudGtmMonitorTemplatesResponse, _err error) {
8472 if dara.BoolValue(client.EnableValidate) == true {
8473 _err = request.Validate()
8474 if _err != nil {
8475 return _result, _err
8476 }
8477 }
8478 query := map[string]interface{}{}
8479 if !dara.IsNil(request.AcceptLanguage) {
8480 query["AcceptLanguage"] = request.AcceptLanguage
8481 }
8482
8483 if !dara.IsNil(request.IpVersion) {
8484 query["IpVersion"] = request.IpVersion
8485 }
8486
8487 if !dara.IsNil(request.Name) {
8488 query["Name"] = request.Name
8489 }
8490
8491 if !dara.IsNil(request.PageNumber) {
8492 query["PageNumber"] = request.PageNumber
8493 }
8494
8495 if !dara.IsNil(request.PageSize) {
8496 query["PageSize"] = request.PageSize
8497 }
8498
8499 if !dara.IsNil(request.Protocol) {
8500 query["Protocol"] = request.Protocol
8501 }
8502
8503 req := &openapiutil.OpenApiRequest{
8504 Query: openapiutil.Query(query),
8505 }
8506 params := &openapiutil.Params{
8507 Action: dara.String("ListCloudGtmMonitorTemplates"),
8508 Version: dara.String("2015-01-09"),
8509 Protocol: dara.String("HTTPS"),
8510 Pathname: dara.String("/"),
8511 Method: dara.String("POST"),
8512 AuthType: dara.String("AK"),
8513 Style: dara.String("RPC"),
8514 ReqBodyType: dara.String("formData"),
8515 BodyType: dara.String("json"),
8516 }
8517 _result = &ListCloudGtmMonitorTemplatesResponse{}
8518 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8519 if _err != nil {
8520 return _result, _err
8521 }
8522 _err = dara.Convert(_body, &_result)
8523 return _result, _err
8524 }
8525
8526 // Summary:
8527 //
8528 // 查询递归解析内置权威解析记录
8529 //
8530 // @param request - ListRecursionRecordsRequest
8531 //
8532 // @param runtime - runtime options for this request RuntimeOptions
8533 //
8534 // @return ListRecursionRecordsResponse
8535 func ListRecursionRecordsWithContext(ctx context.Context, client *Client, request *ListRecursionRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRecursionRecordsResponse, _err error) {
8536 if dara.BoolValue(client.EnableValidate) == true {
8537 _err = request.Validate()
8538 if _err != nil {
8539 return _result, _err
8540 }
8541 }
8542 query := map[string]interface{}{}
8543 if !dara.IsNil(request.Enable) {
8544 query["Enable"] = request.Enable
8545 }
8546
8547 if !dara.IsNil(request.MaxResults) {
8548 query["MaxResults"] = request.MaxResults
8549 }
8550
8551 if !dara.IsNil(request.NextToken) {
8552 query["NextToken"] = request.NextToken
8553 }
8554
8555 if !dara.IsNil(request.PageNumber) {
8556 query["PageNumber"] = request.PageNumber
8557 }
8558
8559 if !dara.IsNil(request.PageSize) {
8560 query["PageSize"] = request.PageSize
8561 }
8562
8563 if !dara.IsNil(request.Remark) {
8564 query["Remark"] = request.Remark
8565 }
8566
8567 if !dara.IsNil(request.RequestSource) {
8568 query["RequestSource"] = request.RequestSource
8569 }
8570
8571 if !dara.IsNil(request.Rr) {
8572 query["Rr"] = request.Rr
8573 }
8574
8575 if !dara.IsNil(request.Ttl) {
8576 query["Ttl"] = request.Ttl
8577 }
8578
8579 if !dara.IsNil(request.Type) {
8580 query["Type"] = request.Type
8581 }
8582
8583 if !dara.IsNil(request.Weight) {
8584 query["Weight"] = request.Weight
8585 }
8586
8587 if !dara.IsNil(request.ZoneId) {
8588 query["ZoneId"] = request.ZoneId
8589 }
8590
8591 req := &openapiutil.OpenApiRequest{
8592 Query: openapiutil.Query(query),
8593 }
8594 params := &openapiutil.Params{
8595 Action: dara.String("ListRecursionRecords"),
8596 Version: dara.String("2015-01-09"),
8597 Protocol: dara.String("HTTPS"),
8598 Pathname: dara.String("/"),
8599 Method: dara.String("POST"),
8600 AuthType: dara.String("AK"),
8601 Style: dara.String("RPC"),
8602 ReqBodyType: dara.String("formData"),
8603 BodyType: dara.String("json"),
8604 }
8605 _result = &ListRecursionRecordsResponse{}
8606 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8607 if _err != nil {
8608 return _result, _err
8609 }
8610 _err = dara.Convert(_body, &_result)
8611 return _result, _err
8612 }
8613
8614 // Summary:
8615 //
8616 // 查询递归解析内置权威域名zone
8617 //
8618 // @param request - ListRecursionZonesRequest
8619 //
8620 // @param runtime - runtime options for this request RuntimeOptions
8621 //
8622 // @return ListRecursionZonesResponse
8623 func ListRecursionZonesWithContext(ctx context.Context, client *Client, request *ListRecursionZonesRequest, runtime *dara.RuntimeOptions) (_result *ListRecursionZonesResponse, _err error) {
8624 if dara.BoolValue(client.EnableValidate) == true {
8625 _err = request.Validate()
8626 if _err != nil {
8627 return _result, _err
8628 }
8629 }
8630 query := map[string]interface{}{}
8631 if !dara.IsNil(request.MaxResults) {
8632 query["MaxResults"] = request.MaxResults
8633 }
8634
8635 if !dara.IsNil(request.NextToken) {
8636 query["NextToken"] = request.NextToken
8637 }
8638
8639 if !dara.IsNil(request.PageNumber) {
8640 query["PageNumber"] = request.PageNumber
8641 }
8642
8643 if !dara.IsNil(request.PageSize) {
8644 query["PageSize"] = request.PageSize
8645 }
8646
8647 if !dara.IsNil(request.Remark) {
8648 query["Remark"] = request.Remark
8649 }
8650
8651 if !dara.IsNil(request.ZoneName) {
8652 query["ZoneName"] = request.ZoneName
8653 }
8654
8655 req := &openapiutil.OpenApiRequest{
8656 Query: openapiutil.Query(query),
8657 }
8658 params := &openapiutil.Params{
8659 Action: dara.String("ListRecursionZones"),
8660 Version: dara.String("2015-01-09"),
8661 Protocol: dara.String("HTTPS"),
8662 Pathname: dara.String("/"),
8663 Method: dara.String("POST"),
8664 AuthType: dara.String("AK"),
8665 Style: dara.String("RPC"),
8666 ReqBodyType: dara.String("formData"),
8667 BodyType: dara.String("json"),
8668 }
8669 _result = &ListRecursionZonesResponse{}
8670 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8671 if _err != nil {
8672 return _result, _err
8673 }
8674 _err = dara.Convert(_body, &_result)
8675 return _result, _err
8676 }
8677
8678 // Summary:
8679 //
8680 // Queries resources by tag.
8681 //
8682 // Description:
8683 //
8684 // 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.
8685 //
8686 // - 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.
8687 //
8688 // - If you set both Tag.N and ResourceId.N to filter tags, ResourceId.N must match all specified key-value pairs.
8689 //
8690 // - If you specify multiple key-value pairs, resources that contain these key-value pairs are returned.
8691 //
8692 // @param request - ListTagResourcesRequest
8693 //
8694 // @param runtime - runtime options for this request RuntimeOptions
8695 //
8696 // @return ListTagResourcesResponse
8697 func ListTagResourcesWithContext(ctx context.Context, client *Client, request *ListTagResourcesRequest, runtime *dara.RuntimeOptions) (_result *ListTagResourcesResponse, _err error) {
8698 if dara.BoolValue(client.EnableValidate) == true {
8699 _err = request.Validate()
8700 if _err != nil {
8701 return _result, _err
8702 }
8703 }
8704 query := map[string]interface{}{}
8705 if !dara.IsNil(request.Lang) {
8706 query["Lang"] = request.Lang
8707 }
8708
8709 if !dara.IsNil(request.NextToken) {
8710 query["NextToken"] = request.NextToken
8711 }
8712
8713 if !dara.IsNil(request.ResourceId) {
8714 query["ResourceId"] = request.ResourceId
8715 }
8716
8717 if !dara.IsNil(request.ResourceType) {
8718 query["ResourceType"] = request.ResourceType
8719 }
8720
8721 if !dara.IsNil(request.Tag) {
8722 query["Tag"] = request.Tag
8723 }
8724
8725 req := &openapiutil.OpenApiRequest{
8726 Query: openapiutil.Query(query),
8727 }
8728 params := &openapiutil.Params{
8729 Action: dara.String("ListTagResources"),
8730 Version: dara.String("2015-01-09"),
8731 Protocol: dara.String("HTTPS"),
8732 Pathname: dara.String("/"),
8733 Method: dara.String("POST"),
8734 AuthType: dara.String("AK"),
8735 Style: dara.String("RPC"),
8736 ReqBodyType: dara.String("formData"),
8737 BodyType: dara.String("json"),
8738 }
8739 _result = &ListTagResourcesResponse{}
8740 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8741 if _err != nil {
8742 return _result, _err
8743 }
8744 _err = dara.Convert(_body, &_result)
8745 return _result, _err
8746 }
8747
8748 // Summary:
8749 //
8750 // 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.
8751 //
8752 // Description:
8753 //
8754 // If the operation succeeds, the names of DNS servers change to those of Alibaba Cloud DNS servers (ending with hichina.com).
8755 //
8756 // > **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.
8757 //
8758 // @param request - ModifyHichinaDomainDNSRequest
8759 //
8760 // @param runtime - runtime options for this request RuntimeOptions
8761 //
8762 // @return ModifyHichinaDomainDNSResponse
8763 func ModifyHichinaDomainDNSWithContext(ctx context.Context, client *Client, request *ModifyHichinaDomainDNSRequest, runtime *dara.RuntimeOptions) (_result *ModifyHichinaDomainDNSResponse, _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.DomainName) {
8772 query["DomainName"] = request.DomainName
8773 }
8774
8775 if !dara.IsNil(request.Lang) {
8776 query["Lang"] = request.Lang
8777 }
8778
8779 if !dara.IsNil(request.UserClientIp) {
8780 query["UserClientIp"] = request.UserClientIp
8781 }
8782
8783 req := &openapiutil.OpenApiRequest{
8784 Query: openapiutil.Query(query),
8785 }
8786 params := &openapiutil.Params{
8787 Action: dara.String("ModifyHichinaDomainDNS"),
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 = &ModifyHichinaDomainDNSResponse{}
8798 _body, _err := client.CallApiWithCtx(ctx, 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 // Moves a domain name to another resource group.
8809 //
8810 // @param request - MoveDomainResourceGroupRequest
8811 //
8812 // @param runtime - runtime options for this request RuntimeOptions
8813 //
8814 // @return MoveDomainResourceGroupResponse
8815 func MoveDomainResourceGroupWithContext(ctx context.Context, client *Client, request *MoveDomainResourceGroupRequest, runtime *dara.RuntimeOptions) (_result *MoveDomainResourceGroupResponse, _err error) {
8816 if dara.BoolValue(client.EnableValidate) == true {
8817 _err = request.Validate()
8818 if _err != nil {
8819 return _result, _err
8820 }
8821 }
8822 query := map[string]interface{}{}
8823 if !dara.IsNil(request.Lang) {
8824 query["Lang"] = request.Lang
8825 }
8826
8827 if !dara.IsNil(request.NewResourceGroupId) {
8828 query["NewResourceGroupId"] = request.NewResourceGroupId
8829 }
8830
8831 if !dara.IsNil(request.ResourceId) {
8832 query["ResourceId"] = request.ResourceId
8833 }
8834
8835 req := &openapiutil.OpenApiRequest{
8836 Query: openapiutil.Query(query),
8837 }
8838 params := &openapiutil.Params{
8839 Action: dara.String("MoveDomainResourceGroup"),
8840 Version: dara.String("2015-01-09"),
8841 Protocol: dara.String("HTTPS"),
8842 Pathname: dara.String("/"),
8843 Method: dara.String("POST"),
8844 AuthType: dara.String("AK"),
8845 Style: dara.String("RPC"),
8846 ReqBodyType: dara.String("formData"),
8847 BodyType: dara.String("json"),
8848 }
8849 _result = &MoveDomainResourceGroupResponse{}
8850 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8851 if _err != nil {
8852 return _result, _err
8853 }
8854 _err = dara.Convert(_body, &_result)
8855 return _result, _err
8856 }
8857
8858 // @param request - MoveGtmResourceGroupRequest
8859 //
8860 // @param runtime - runtime options for this request RuntimeOptions
8861 //
8862 // @return MoveGtmResourceGroupResponse
8863 func MoveGtmResourceGroupWithContext(ctx context.Context, client *Client, request *MoveGtmResourceGroupRequest, runtime *dara.RuntimeOptions) (_result *MoveGtmResourceGroupResponse, _err error) {
8864 if dara.BoolValue(client.EnableValidate) == true {
8865 _err = request.Validate()
8866 if _err != nil {
8867 return _result, _err
8868 }
8869 }
8870 query := map[string]interface{}{}
8871 if !dara.IsNil(request.Lang) {
8872 query["Lang"] = request.Lang
8873 }
8874
8875 if !dara.IsNil(request.NewResourceGroupId) {
8876 query["NewResourceGroupId"] = request.NewResourceGroupId
8877 }
8878
8879 if !dara.IsNil(request.ResourceId) {
8880 query["ResourceId"] = request.ResourceId
8881 }
8882
8883 req := &openapiutil.OpenApiRequest{
8884 Query: openapiutil.Query(query),
8885 }
8886 params := &openapiutil.Params{
8887 Action: dara.String("MoveGtmResourceGroup"),
8888 Version: dara.String("2015-01-09"),
8889 Protocol: dara.String("HTTPS"),
8890 Pathname: dara.String("/"),
8891 Method: dara.String("POST"),
8892 AuthType: dara.String("AK"),
8893 Style: dara.String("RPC"),
8894 ReqBodyType: dara.String("formData"),
8895 BodyType: dara.String("json"),
8896 }
8897 _result = &MoveGtmResourceGroupResponse{}
8898 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8899 if _err != nil {
8900 return _result, _err
8901 }
8902 _err = dara.Convert(_body, &_result)
8903 return _result, _err
8904 }
8905
8906 // Summary:
8907 //
8908 // Adds or deletes domain names and Domain Name System (DNS) records in batches.
8909 //
8910 // Description:
8911 //
8912 // Scenario: You need to execute a large number of tasks related to DNS resolution and you do not have high requirements for efficiency.
8913 //
8914 // @param request - OperateBatchDomainRequest
8915 //
8916 // @param runtime - runtime options for this request RuntimeOptions
8917 //
8918 // @return OperateBatchDomainResponse
8919 func OperateBatchDomainWithContext(ctx context.Context, client *Client, request *OperateBatchDomainRequest, runtime *dara.RuntimeOptions) (_result *OperateBatchDomainResponse, _err error) {
8920 if dara.BoolValue(client.EnableValidate) == true {
8921 _err = request.Validate()
8922 if _err != nil {
8923 return _result, _err
8924 }
8925 }
8926 query := map[string]interface{}{}
8927 if !dara.IsNil(request.DomainRecordInfo) {
8928 query["DomainRecordInfo"] = request.DomainRecordInfo
8929 }
8930
8931 if !dara.IsNil(request.Lang) {
8932 query["Lang"] = request.Lang
8933 }
8934
8935 if !dara.IsNil(request.Type) {
8936 query["Type"] = request.Type
8937 }
8938
8939 req := &openapiutil.OpenApiRequest{
8940 Query: openapiutil.Query(query),
8941 }
8942 params := &openapiutil.Params{
8943 Action: dara.String("OperateBatchDomain"),
8944 Version: dara.String("2015-01-09"),
8945 Protocol: dara.String("HTTPS"),
8946 Pathname: dara.String("/"),
8947 Method: dara.String("POST"),
8948 AuthType: dara.String("AK"),
8949 Style: dara.String("RPC"),
8950 ReqBodyType: dara.String("formData"),
8951 BodyType: dara.String("json"),
8952 }
8953 _result = &OperateBatchDomainResponse{}
8954 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8955 if _err != nil {
8956 return _result, _err
8957 }
8958 _err = dara.Convert(_body, &_result)
8959 return _result, _err
8960 }
8961
8962 // Summary:
8963 //
8964 // 暂停公共DNS服务
8965 //
8966 // @param request - PausePdnsServiceRequest
8967 //
8968 // @param runtime - runtime options for this request RuntimeOptions
8969 //
8970 // @return PausePdnsServiceResponse
8971 func PausePdnsServiceWithContext(ctx context.Context, client *Client, request *PausePdnsServiceRequest, runtime *dara.RuntimeOptions) (_result *PausePdnsServiceResponse, _err error) {
8972 if dara.BoolValue(client.EnableValidate) == true {
8973 _err = request.Validate()
8974 if _err != nil {
8975 return _result, _err
8976 }
8977 }
8978 query := map[string]interface{}{}
8979 if !dara.IsNil(request.Lang) {
8980 query["Lang"] = request.Lang
8981 }
8982
8983 if !dara.IsNil(request.ServiceType) {
8984 query["ServiceType"] = request.ServiceType
8985 }
8986
8987 req := &openapiutil.OpenApiRequest{
8988 Query: openapiutil.Query(query),
8989 }
8990 params := &openapiutil.Params{
8991 Action: dara.String("PausePdnsService"),
8992 Version: dara.String("2015-01-09"),
8993 Protocol: dara.String("HTTPS"),
8994 Pathname: dara.String("/"),
8995 Method: dara.String("POST"),
8996 AuthType: dara.String("AK"),
8997 Style: dara.String("RPC"),
8998 ReqBodyType: dara.String("formData"),
8999 BodyType: dara.String("json"),
9000 }
9001 _result = &PausePdnsServiceResponse{}
9002 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9003 if _err != nil {
9004 return _result, _err
9005 }
9006 _err = dara.Convert(_body, &_result)
9007 return _result, _err
9008 }
9009
9010 // Summary:
9011 //
9012 // You can call this operation to preview a disaster recovery plan of a Global Traffic Manager (GTM) instance.
9013 //
9014 // @param request - PreviewGtmRecoveryPlanRequest
9015 //
9016 // @param runtime - runtime options for this request RuntimeOptions
9017 //
9018 // @return PreviewGtmRecoveryPlanResponse
9019 func PreviewGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *PreviewGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *PreviewGtmRecoveryPlanResponse, _err error) {
9020 if dara.BoolValue(client.EnableValidate) == true {
9021 _err = request.Validate()
9022 if _err != nil {
9023 return _result, _err
9024 }
9025 }
9026 query := map[string]interface{}{}
9027 if !dara.IsNil(request.Lang) {
9028 query["Lang"] = request.Lang
9029 }
9030
9031 if !dara.IsNil(request.PageNumber) {
9032 query["PageNumber"] = request.PageNumber
9033 }
9034
9035 if !dara.IsNil(request.PageSize) {
9036 query["PageSize"] = request.PageSize
9037 }
9038
9039 if !dara.IsNil(request.RecoveryPlanId) {
9040 query["RecoveryPlanId"] = request.RecoveryPlanId
9041 }
9042
9043 req := &openapiutil.OpenApiRequest{
9044 Query: openapiutil.Query(query),
9045 }
9046 params := &openapiutil.Params{
9047 Action: dara.String("PreviewGtmRecoveryPlan"),
9048 Version: dara.String("2015-01-09"),
9049 Protocol: dara.String("HTTPS"),
9050 Pathname: dara.String("/"),
9051 Method: dara.String("POST"),
9052 AuthType: dara.String("AK"),
9053 Style: dara.String("RPC"),
9054 ReqBodyType: dara.String("formData"),
9055 BodyType: dara.String("json"),
9056 }
9057 _result = &PreviewGtmRecoveryPlanResponse{}
9058 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9059 if _err != nil {
9060 return _result, _err
9061 }
9062 _err = dara.Convert(_body, &_result)
9063 return _result, _err
9064 }
9065
9066 // Summary:
9067 //
9068 // 删除公共DNS AppKey
9069 //
9070 // @param request - RemovePdnsAppKeyRequest
9071 //
9072 // @param runtime - runtime options for this request RuntimeOptions
9073 //
9074 // @return RemovePdnsAppKeyResponse
9075 func RemovePdnsAppKeyWithContext(ctx context.Context, client *Client, request *RemovePdnsAppKeyRequest, runtime *dara.RuntimeOptions) (_result *RemovePdnsAppKeyResponse, _err error) {
9076 if dara.BoolValue(client.EnableValidate) == true {
9077 _err = request.Validate()
9078 if _err != nil {
9079 return _result, _err
9080 }
9081 }
9082 query := map[string]interface{}{}
9083 if !dara.IsNil(request.AppKeyId) {
9084 query["AppKeyId"] = request.AppKeyId
9085 }
9086
9087 if !dara.IsNil(request.Lang) {
9088 query["Lang"] = request.Lang
9089 }
9090
9091 req := &openapiutil.OpenApiRequest{
9092 Query: openapiutil.Query(query),
9093 }
9094 params := &openapiutil.Params{
9095 Action: dara.String("RemovePdnsAppKey"),
9096 Version: dara.String("2015-01-09"),
9097 Protocol: dara.String("HTTPS"),
9098 Pathname: dara.String("/"),
9099 Method: dara.String("POST"),
9100 AuthType: dara.String("AK"),
9101 Style: dara.String("RPC"),
9102 ReqBodyType: dara.String("formData"),
9103 BodyType: dara.String("json"),
9104 }
9105 _result = &RemovePdnsAppKeyResponse{}
9106 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9107 if _err != nil {
9108 return _result, _err
9109 }
9110 _err = dara.Convert(_body, &_result)
9111 return _result, _err
9112 }
9113
9114 // Summary:
9115 //
9116 // 删除公共DNS Udp Ip地址段
9117 //
9118 // @param request - RemovePdnsUdpIpSegmentRequest
9119 //
9120 // @param runtime - runtime options for this request RuntimeOptions
9121 //
9122 // @return RemovePdnsUdpIpSegmentResponse
9123 func RemovePdnsUdpIpSegmentWithContext(ctx context.Context, client *Client, request *RemovePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *RemovePdnsUdpIpSegmentResponse, _err error) {
9124 if dara.BoolValue(client.EnableValidate) == true {
9125 _err = request.Validate()
9126 if _err != nil {
9127 return _result, _err
9128 }
9129 }
9130 query := map[string]interface{}{}
9131 if !dara.IsNil(request.Ip) {
9132 query["Ip"] = request.Ip
9133 }
9134
9135 if !dara.IsNil(request.Lang) {
9136 query["Lang"] = request.Lang
9137 }
9138
9139 req := &openapiutil.OpenApiRequest{
9140 Query: openapiutil.Query(query),
9141 }
9142 params := &openapiutil.Params{
9143 Action: dara.String("RemovePdnsUdpIpSegment"),
9144 Version: dara.String("2015-01-09"),
9145 Protocol: dara.String("HTTPS"),
9146 Pathname: dara.String("/"),
9147 Method: dara.String("POST"),
9148 AuthType: dara.String("AK"),
9149 Style: dara.String("RPC"),
9150 ReqBodyType: dara.String("formData"),
9151 BodyType: dara.String("json"),
9152 }
9153 _result = &RemovePdnsUdpIpSegmentResponse{}
9154 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9155 if _err != nil {
9156 return _result, _err
9157 }
9158 _err = dara.Convert(_body, &_result)
9159 return _result, _err
9160 }
9161
9162 // Summary:
9163 //
9164 // Replaces the addresses referenced by an address pool.
9165 //
9166 // @param tmpReq - ReplaceCloudGtmAddressPoolAddressRequest
9167 //
9168 // @param runtime - runtime options for this request RuntimeOptions
9169 //
9170 // @return ReplaceCloudGtmAddressPoolAddressResponse
9171 func ReplaceCloudGtmAddressPoolAddressWithContext(ctx context.Context, client *Client, tmpReq *ReplaceCloudGtmAddressPoolAddressRequest, runtime *dara.RuntimeOptions) (_result *ReplaceCloudGtmAddressPoolAddressResponse, _err error) {
9172 if dara.BoolValue(client.EnableValidate) == true {
9173 _err = tmpReq.Validate()
9174 if _err != nil {
9175 return _result, _err
9176 }
9177 }
9178 request := &ReplaceCloudGtmAddressPoolAddressShrinkRequest{}
9179 openapiutil.Convert(tmpReq, request)
9180 if !dara.IsNil(tmpReq.Addresses) {
9181 request.AddressesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Addresses, dara.String("Addresses"), dara.String("json"))
9182 }
9183
9184 query := map[string]interface{}{}
9185 if !dara.IsNil(request.AcceptLanguage) {
9186 query["AcceptLanguage"] = request.AcceptLanguage
9187 }
9188
9189 if !dara.IsNil(request.AddressPoolId) {
9190 query["AddressPoolId"] = request.AddressPoolId
9191 }
9192
9193 if !dara.IsNil(request.AddressesShrink) {
9194 query["Addresses"] = request.AddressesShrink
9195 }
9196
9197 if !dara.IsNil(request.ClientToken) {
9198 query["ClientToken"] = request.ClientToken
9199 }
9200
9201 req := &openapiutil.OpenApiRequest{
9202 Query: openapiutil.Query(query),
9203 }
9204 params := &openapiutil.Params{
9205 Action: dara.String("ReplaceCloudGtmAddressPoolAddress"),
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 = &ReplaceCloudGtmAddressPoolAddressResponse{}
9216 _body, _err := client.CallApiWithCtx(ctx, 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 // Replaces address pools that are associated with a Global Traffic Manager (GTM) 3.0 instance with new address pools.
9227 //
9228 // @param tmpReq - ReplaceCloudGtmInstanceConfigAddressPoolRequest
9229 //
9230 // @param runtime - runtime options for this request RuntimeOptions
9231 //
9232 // @return ReplaceCloudGtmInstanceConfigAddressPoolResponse
9233 func ReplaceCloudGtmInstanceConfigAddressPoolWithContext(ctx context.Context, client *Client, tmpReq *ReplaceCloudGtmInstanceConfigAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *ReplaceCloudGtmInstanceConfigAddressPoolResponse, _err error) {
9234 if dara.BoolValue(client.EnableValidate) == true {
9235 _err = tmpReq.Validate()
9236 if _err != nil {
9237 return _result, _err
9238 }
9239 }
9240 request := &ReplaceCloudGtmInstanceConfigAddressPoolShrinkRequest{}
9241 openapiutil.Convert(tmpReq, request)
9242 if !dara.IsNil(tmpReq.AddressPools) {
9243 request.AddressPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AddressPools, dara.String("AddressPools"), dara.String("json"))
9244 }
9245
9246 query := map[string]interface{}{}
9247 if !dara.IsNil(request.AcceptLanguage) {
9248 query["AcceptLanguage"] = request.AcceptLanguage
9249 }
9250
9251 if !dara.IsNil(request.AddressPoolsShrink) {
9252 query["AddressPools"] = request.AddressPoolsShrink
9253 }
9254
9255 if !dara.IsNil(request.ClientToken) {
9256 query["ClientToken"] = request.ClientToken
9257 }
9258
9259 if !dara.IsNil(request.ConfigId) {
9260 query["ConfigId"] = request.ConfigId
9261 }
9262
9263 if !dara.IsNil(request.InstanceId) {
9264 query["InstanceId"] = request.InstanceId
9265 }
9266
9267 req := &openapiutil.OpenApiRequest{
9268 Query: openapiutil.Query(query),
9269 }
9270 params := &openapiutil.Params{
9271 Action: dara.String("ReplaceCloudGtmInstanceConfigAddressPool"),
9272 Version: dara.String("2015-01-09"),
9273 Protocol: dara.String("HTTPS"),
9274 Pathname: dara.String("/"),
9275 Method: dara.String("POST"),
9276 AuthType: dara.String("AK"),
9277 Style: dara.String("RPC"),
9278 ReqBodyType: dara.String("formData"),
9279 BodyType: dara.String("json"),
9280 }
9281 _result = &ReplaceCloudGtmInstanceConfigAddressPoolResponse{}
9282 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9283 if _err != nil {
9284 return _result, _err
9285 }
9286 _err = dara.Convert(_body, &_result)
9287 return _result, _err
9288 }
9289
9290 // Summary:
9291 //
9292 // 恢复公共DNS服务
9293 //
9294 // @param request - ResumePdnsServiceRequest
9295 //
9296 // @param runtime - runtime options for this request RuntimeOptions
9297 //
9298 // @return ResumePdnsServiceResponse
9299 func ResumePdnsServiceWithContext(ctx context.Context, client *Client, request *ResumePdnsServiceRequest, runtime *dara.RuntimeOptions) (_result *ResumePdnsServiceResponse, _err error) {
9300 if dara.BoolValue(client.EnableValidate) == true {
9301 _err = request.Validate()
9302 if _err != nil {
9303 return _result, _err
9304 }
9305 }
9306 query := map[string]interface{}{}
9307 if !dara.IsNil(request.Lang) {
9308 query["Lang"] = request.Lang
9309 }
9310
9311 if !dara.IsNil(request.ServiceType) {
9312 query["ServiceType"] = request.ServiceType
9313 }
9314
9315 req := &openapiutil.OpenApiRequest{
9316 Query: openapiutil.Query(query),
9317 }
9318 params := &openapiutil.Params{
9319 Action: dara.String("ResumePdnsService"),
9320 Version: dara.String("2015-01-09"),
9321 Protocol: dara.String("HTTPS"),
9322 Pathname: dara.String("/"),
9323 Method: dara.String("POST"),
9324 AuthType: dara.String("AK"),
9325 Style: dara.String("RPC"),
9326 ReqBodyType: dara.String("formData"),
9327 BodyType: dara.String("json"),
9328 }
9329 _result = &ResumePdnsServiceResponse{}
9330 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9331 if _err != nil {
9332 return _result, _err
9333 }
9334 _err = dara.Convert(_body, &_result)
9335 return _result, _err
9336 }
9337
9338 // Summary:
9339 //
9340 // Retrieves a domain name.
9341 //
9342 // Description:
9343 //
9344 // 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.
9345 //
9346 // @param request - RetrieveDomainRequest
9347 //
9348 // @param runtime - runtime options for this request RuntimeOptions
9349 //
9350 // @return RetrieveDomainResponse
9351 func RetrieveDomainWithContext(ctx context.Context, client *Client, request *RetrieveDomainRequest, runtime *dara.RuntimeOptions) (_result *RetrieveDomainResponse, _err error) {
9352 if dara.BoolValue(client.EnableValidate) == true {
9353 _err = request.Validate()
9354 if _err != nil {
9355 return _result, _err
9356 }
9357 }
9358 query := map[string]interface{}{}
9359 if !dara.IsNil(request.DomainName) {
9360 query["DomainName"] = request.DomainName
9361 }
9362
9363 if !dara.IsNil(request.Lang) {
9364 query["Lang"] = request.Lang
9365 }
9366
9367 req := &openapiutil.OpenApiRequest{
9368 Query: openapiutil.Query(query),
9369 }
9370 params := &openapiutil.Params{
9371 Action: dara.String("RetrieveDomain"),
9372 Version: dara.String("2015-01-09"),
9373 Protocol: dara.String("HTTPS"),
9374 Pathname: dara.String("/"),
9375 Method: dara.String("POST"),
9376 AuthType: dara.String("AK"),
9377 Style: dara.String("RPC"),
9378 ReqBodyType: dara.String("formData"),
9379 BodyType: dara.String("json"),
9380 }
9381 _result = &RetrieveDomainResponse{}
9382 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9383 if _err != nil {
9384 return _result, _err
9385 }
9386 _err = dara.Convert(_body, &_result)
9387 return _result, _err
9388 }
9389
9390 // Summary:
9391 //
9392 // Rolls back a disaster recovery plan.
9393 //
9394 // @param request - RollbackGtmRecoveryPlanRequest
9395 //
9396 // @param runtime - runtime options for this request RuntimeOptions
9397 //
9398 // @return RollbackGtmRecoveryPlanResponse
9399 func RollbackGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *RollbackGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *RollbackGtmRecoveryPlanResponse, _err error) {
9400 if dara.BoolValue(client.EnableValidate) == true {
9401 _err = request.Validate()
9402 if _err != nil {
9403 return _result, _err
9404 }
9405 }
9406 query := map[string]interface{}{}
9407 if !dara.IsNil(request.Lang) {
9408 query["Lang"] = request.Lang
9409 }
9410
9411 if !dara.IsNil(request.RecoveryPlanId) {
9412 query["RecoveryPlanId"] = request.RecoveryPlanId
9413 }
9414
9415 req := &openapiutil.OpenApiRequest{
9416 Query: openapiutil.Query(query),
9417 }
9418 params := &openapiutil.Params{
9419 Action: dara.String("RollbackGtmRecoveryPlan"),
9420 Version: dara.String("2015-01-09"),
9421 Protocol: dara.String("HTTPS"),
9422 Pathname: dara.String("/"),
9423 Method: dara.String("POST"),
9424 AuthType: dara.String("AK"),
9425 Style: dara.String("RPC"),
9426 ReqBodyType: dara.String("formData"),
9427 BodyType: dara.String("json"),
9428 }
9429 _result = &RollbackGtmRecoveryPlanResponse{}
9430 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9431 if _err != nil {
9432 return _result, _err
9433 }
9434 _err = dara.Convert(_body, &_result)
9435 return _result, _err
9436 }
9437
9438 // Summary:
9439 //
9440 // Queries a list of address pools.
9441 //
9442 // @param request - SearchCloudGtmAddressPoolsRequest
9443 //
9444 // @param runtime - runtime options for this request RuntimeOptions
9445 //
9446 // @return SearchCloudGtmAddressPoolsResponse
9447 func SearchCloudGtmAddressPoolsWithContext(ctx context.Context, client *Client, request *SearchCloudGtmAddressPoolsRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmAddressPoolsResponse, _err error) {
9448 if dara.BoolValue(client.EnableValidate) == true {
9449 _err = request.Validate()
9450 if _err != nil {
9451 return _result, _err
9452 }
9453 }
9454 query := map[string]interface{}{}
9455 if !dara.IsNil(request.AcceptLanguage) {
9456 query["AcceptLanguage"] = request.AcceptLanguage
9457 }
9458
9459 if !dara.IsNil(request.AddressPoolName) {
9460 query["AddressPoolName"] = request.AddressPoolName
9461 }
9462
9463 if !dara.IsNil(request.AddressPoolType) {
9464 query["AddressPoolType"] = request.AddressPoolType
9465 }
9466
9467 if !dara.IsNil(request.AvailableStatus) {
9468 query["AvailableStatus"] = request.AvailableStatus
9469 }
9470
9471 if !dara.IsNil(request.ClientToken) {
9472 query["ClientToken"] = request.ClientToken
9473 }
9474
9475 if !dara.IsNil(request.EnableStatus) {
9476 query["EnableStatus"] = request.EnableStatus
9477 }
9478
9479 if !dara.IsNil(request.HealthStatus) {
9480 query["HealthStatus"] = request.HealthStatus
9481 }
9482
9483 if !dara.IsNil(request.PageNumber) {
9484 query["PageNumber"] = request.PageNumber
9485 }
9486
9487 if !dara.IsNil(request.PageSize) {
9488 query["PageSize"] = request.PageSize
9489 }
9490
9491 if !dara.IsNil(request.Remark) {
9492 query["Remark"] = request.Remark
9493 }
9494
9495 req := &openapiutil.OpenApiRequest{
9496 Query: openapiutil.Query(query),
9497 }
9498 params := &openapiutil.Params{
9499 Action: dara.String("SearchCloudGtmAddressPools"),
9500 Version: dara.String("2015-01-09"),
9501 Protocol: dara.String("HTTPS"),
9502 Pathname: dara.String("/"),
9503 Method: dara.String("POST"),
9504 AuthType: dara.String("AK"),
9505 Style: dara.String("RPC"),
9506 ReqBodyType: dara.String("formData"),
9507 BodyType: dara.String("json"),
9508 }
9509 _result = &SearchCloudGtmAddressPoolsResponse{}
9510 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9511 if _err != nil {
9512 return _result, _err
9513 }
9514 _err = dara.Convert(_body, &_result)
9515 return _result, _err
9516 }
9517
9518 // Summary:
9519 //
9520 // Queries a list of addresses based on address names, descriptions, health check templates referenced by the addresses, or address IDs.
9521 //
9522 // @param request - SearchCloudGtmAddressesRequest
9523 //
9524 // @param runtime - runtime options for this request RuntimeOptions
9525 //
9526 // @return SearchCloudGtmAddressesResponse
9527 func SearchCloudGtmAddressesWithContext(ctx context.Context, client *Client, request *SearchCloudGtmAddressesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmAddressesResponse, _err error) {
9528 if dara.BoolValue(client.EnableValidate) == true {
9529 _err = request.Validate()
9530 if _err != nil {
9531 return _result, _err
9532 }
9533 }
9534 query := map[string]interface{}{}
9535 if !dara.IsNil(request.AcceptLanguage) {
9536 query["AcceptLanguage"] = request.AcceptLanguage
9537 }
9538
9539 if !dara.IsNil(request.Address) {
9540 query["Address"] = request.Address
9541 }
9542
9543 if !dara.IsNil(request.AddressId) {
9544 query["AddressId"] = request.AddressId
9545 }
9546
9547 if !dara.IsNil(request.AvailableStatus) {
9548 query["AvailableStatus"] = request.AvailableStatus
9549 }
9550
9551 if !dara.IsNil(request.EnableStatus) {
9552 query["EnableStatus"] = request.EnableStatus
9553 }
9554
9555 if !dara.IsNil(request.HealthStatus) {
9556 query["HealthStatus"] = request.HealthStatus
9557 }
9558
9559 if !dara.IsNil(request.MonitorTemplateName) {
9560 query["MonitorTemplateName"] = request.MonitorTemplateName
9561 }
9562
9563 if !dara.IsNil(request.NameSearchCondition) {
9564 query["NameSearchCondition"] = request.NameSearchCondition
9565 }
9566
9567 if !dara.IsNil(request.Names) {
9568 query["Names"] = request.Names
9569 }
9570
9571 if !dara.IsNil(request.PageNumber) {
9572 query["PageNumber"] = request.PageNumber
9573 }
9574
9575 if !dara.IsNil(request.PageSize) {
9576 query["PageSize"] = request.PageSize
9577 }
9578
9579 if !dara.IsNil(request.RemarkSearchCondition) {
9580 query["RemarkSearchCondition"] = request.RemarkSearchCondition
9581 }
9582
9583 if !dara.IsNil(request.Remarks) {
9584 query["Remarks"] = request.Remarks
9585 }
9586
9587 if !dara.IsNil(request.Type) {
9588 query["Type"] = request.Type
9589 }
9590
9591 req := &openapiutil.OpenApiRequest{
9592 Query: openapiutil.Query(query),
9593 }
9594 params := &openapiutil.Params{
9595 Action: dara.String("SearchCloudGtmAddresses"),
9596 Version: dara.String("2015-01-09"),
9597 Protocol: dara.String("HTTPS"),
9598 Pathname: dara.String("/"),
9599 Method: dara.String("POST"),
9600 AuthType: dara.String("AK"),
9601 Style: dara.String("RPC"),
9602 ReqBodyType: dara.String("formData"),
9603 BodyType: dara.String("json"),
9604 }
9605 _result = &SearchCloudGtmAddressesResponse{}
9606 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9607 if _err != nil {
9608 return _result, _err
9609 }
9610 _err = dara.Convert(_body, &_result)
9611 return _result, _err
9612 }
9613
9614 // Summary:
9615 //
9616 // Queries the configurations of an access domain name.
9617 //
9618 // @param request - SearchCloudGtmInstanceConfigsRequest
9619 //
9620 // @param runtime - runtime options for this request RuntimeOptions
9621 //
9622 // @return SearchCloudGtmInstanceConfigsResponse
9623 func SearchCloudGtmInstanceConfigsWithContext(ctx context.Context, client *Client, request *SearchCloudGtmInstanceConfigsRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmInstanceConfigsResponse, _err error) {
9624 if dara.BoolValue(client.EnableValidate) == true {
9625 _err = request.Validate()
9626 if _err != nil {
9627 return _result, _err
9628 }
9629 }
9630 query := map[string]interface{}{}
9631 if !dara.IsNil(request.AcceptLanguage) {
9632 query["AcceptLanguage"] = request.AcceptLanguage
9633 }
9634
9635 if !dara.IsNil(request.AvailableStatus) {
9636 query["AvailableStatus"] = request.AvailableStatus
9637 }
9638
9639 if !dara.IsNil(request.ClientToken) {
9640 query["ClientToken"] = request.ClientToken
9641 }
9642
9643 if !dara.IsNil(request.EnableStatus) {
9644 query["EnableStatus"] = request.EnableStatus
9645 }
9646
9647 if !dara.IsNil(request.HealthStatus) {
9648 query["HealthStatus"] = request.HealthStatus
9649 }
9650
9651 if !dara.IsNil(request.InstanceId) {
9652 query["InstanceId"] = request.InstanceId
9653 }
9654
9655 if !dara.IsNil(request.PageNumber) {
9656 query["PageNumber"] = request.PageNumber
9657 }
9658
9659 if !dara.IsNil(request.PageSize) {
9660 query["PageSize"] = request.PageSize
9661 }
9662
9663 if !dara.IsNil(request.Remark) {
9664 query["Remark"] = request.Remark
9665 }
9666
9667 if !dara.IsNil(request.ScheduleDomainName) {
9668 query["ScheduleDomainName"] = request.ScheduleDomainName
9669 }
9670
9671 if !dara.IsNil(request.ScheduleZoneName) {
9672 query["ScheduleZoneName"] = request.ScheduleZoneName
9673 }
9674
9675 req := &openapiutil.OpenApiRequest{
9676 Query: openapiutil.Query(query),
9677 }
9678 params := &openapiutil.Params{
9679 Action: dara.String("SearchCloudGtmInstanceConfigs"),
9680 Version: dara.String("2015-01-09"),
9681 Protocol: dara.String("HTTPS"),
9682 Pathname: dara.String("/"),
9683 Method: dara.String("POST"),
9684 AuthType: dara.String("AK"),
9685 Style: dara.String("RPC"),
9686 ReqBodyType: dara.String("formData"),
9687 BodyType: dara.String("json"),
9688 }
9689 _result = &SearchCloudGtmInstanceConfigsResponse{}
9690 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9691 if _err != nil {
9692 return _result, _err
9693 }
9694 _err = dara.Convert(_body, &_result)
9695 return _result, _err
9696 }
9697
9698 // Summary:
9699 //
9700 // Queries a list of instances.
9701 //
9702 // @param request - SearchCloudGtmInstancesRequest
9703 //
9704 // @param runtime - runtime options for this request RuntimeOptions
9705 //
9706 // @return SearchCloudGtmInstancesResponse
9707 func SearchCloudGtmInstancesWithContext(ctx context.Context, client *Client, request *SearchCloudGtmInstancesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmInstancesResponse, _err error) {
9708 if dara.BoolValue(client.EnableValidate) == true {
9709 _err = request.Validate()
9710 if _err != nil {
9711 return _result, _err
9712 }
9713 }
9714 query := map[string]interface{}{}
9715 if !dara.IsNil(request.AcceptLanguage) {
9716 query["AcceptLanguage"] = request.AcceptLanguage
9717 }
9718
9719 if !dara.IsNil(request.ChargeType) {
9720 query["ChargeType"] = request.ChargeType
9721 }
9722
9723 if !dara.IsNil(request.ClientToken) {
9724 query["ClientToken"] = request.ClientToken
9725 }
9726
9727 if !dara.IsNil(request.InstanceId) {
9728 query["InstanceId"] = request.InstanceId
9729 }
9730
9731 if !dara.IsNil(request.InstanceName) {
9732 query["InstanceName"] = request.InstanceName
9733 }
9734
9735 if !dara.IsNil(request.PageNumber) {
9736 query["PageNumber"] = request.PageNumber
9737 }
9738
9739 if !dara.IsNil(request.PageSize) {
9740 query["PageSize"] = request.PageSize
9741 }
9742
9743 req := &openapiutil.OpenApiRequest{
9744 Query: openapiutil.Query(query),
9745 }
9746 params := &openapiutil.Params{
9747 Action: dara.String("SearchCloudGtmInstances"),
9748 Version: dara.String("2015-01-09"),
9749 Protocol: dara.String("HTTPS"),
9750 Pathname: dara.String("/"),
9751 Method: dara.String("POST"),
9752 AuthType: dara.String("AK"),
9753 Style: dara.String("RPC"),
9754 ReqBodyType: dara.String("formData"),
9755 BodyType: dara.String("json"),
9756 }
9757 _result = &SearchCloudGtmInstancesResponse{}
9758 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9759 if _err != nil {
9760 return _result, _err
9761 }
9762 _err = dara.Convert(_body, &_result)
9763 return _result, _err
9764 }
9765
9766 // Summary:
9767 //
9768 // Queries the list of health check templates.
9769 //
9770 // @param request - SearchCloudGtmMonitorTemplatesRequest
9771 //
9772 // @param runtime - runtime options for this request RuntimeOptions
9773 //
9774 // @return SearchCloudGtmMonitorTemplatesResponse
9775 func SearchCloudGtmMonitorTemplatesWithContext(ctx context.Context, client *Client, request *SearchCloudGtmMonitorTemplatesRequest, runtime *dara.RuntimeOptions) (_result *SearchCloudGtmMonitorTemplatesResponse, _err error) {
9776 if dara.BoolValue(client.EnableValidate) == true {
9777 _err = request.Validate()
9778 if _err != nil {
9779 return _result, _err
9780 }
9781 }
9782 query := map[string]interface{}{}
9783 if !dara.IsNil(request.AcceptLanguage) {
9784 query["AcceptLanguage"] = request.AcceptLanguage
9785 }
9786
9787 if !dara.IsNil(request.IpVersion) {
9788 query["IpVersion"] = request.IpVersion
9789 }
9790
9791 if !dara.IsNil(request.Name) {
9792 query["Name"] = request.Name
9793 }
9794
9795 if !dara.IsNil(request.PageNumber) {
9796 query["PageNumber"] = request.PageNumber
9797 }
9798
9799 if !dara.IsNil(request.PageSize) {
9800 query["PageSize"] = request.PageSize
9801 }
9802
9803 if !dara.IsNil(request.Protocol) {
9804 query["Protocol"] = request.Protocol
9805 }
9806
9807 req := &openapiutil.OpenApiRequest{
9808 Query: openapiutil.Query(query),
9809 }
9810 params := &openapiutil.Params{
9811 Action: dara.String("SearchCloudGtmMonitorTemplates"),
9812 Version: dara.String("2015-01-09"),
9813 Protocol: dara.String("HTTPS"),
9814 Pathname: dara.String("/"),
9815 Method: dara.String("POST"),
9816 AuthType: dara.String("AK"),
9817 Style: dara.String("RPC"),
9818 ReqBodyType: dara.String("formData"),
9819 BodyType: dara.String("json"),
9820 }
9821 _result = &SearchCloudGtmMonitorTemplatesResponse{}
9822 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9823 if _err != nil {
9824 return _result, _err
9825 }
9826 _err = dara.Convert(_body, &_result)
9827 return _result, _err
9828 }
9829
9830 // Summary:
9831 //
9832 // 搜索递归解析内置权威解析记录
9833 //
9834 // @param request - SearchRecursionRecordsRequest
9835 //
9836 // @param runtime - runtime options for this request RuntimeOptions
9837 //
9838 // @return SearchRecursionRecordsResponse
9839 func SearchRecursionRecordsWithContext(ctx context.Context, client *Client, request *SearchRecursionRecordsRequest, runtime *dara.RuntimeOptions) (_result *SearchRecursionRecordsResponse, _err error) {
9840 if dara.BoolValue(client.EnableValidate) == true {
9841 _err = request.Validate()
9842 if _err != nil {
9843 return _result, _err
9844 }
9845 }
9846 query := map[string]interface{}{}
9847 if !dara.IsNil(request.Direction) {
9848 query["Direction"] = request.Direction
9849 }
9850
9851 if !dara.IsNil(request.EnableStatus) {
9852 query["EnableStatus"] = request.EnableStatus
9853 }
9854
9855 if !dara.IsNil(request.MaxResults) {
9856 query["MaxResults"] = request.MaxResults
9857 }
9858
9859 if !dara.IsNil(request.NextToken) {
9860 query["NextToken"] = request.NextToken
9861 }
9862
9863 if !dara.IsNil(request.OrderBy) {
9864 query["OrderBy"] = request.OrderBy
9865 }
9866
9867 if !dara.IsNil(request.PageNumber) {
9868 query["PageNumber"] = request.PageNumber
9869 }
9870
9871 if !dara.IsNil(request.PageSize) {
9872 query["PageSize"] = request.PageSize
9873 }
9874
9875 if !dara.IsNil(request.Remark) {
9876 query["Remark"] = request.Remark
9877 }
9878
9879 if !dara.IsNil(request.RequestSource) {
9880 query["RequestSource"] = request.RequestSource
9881 }
9882
9883 if !dara.IsNil(request.Rr) {
9884 query["Rr"] = request.Rr
9885 }
9886
9887 if !dara.IsNil(request.Ttl) {
9888 query["Ttl"] = request.Ttl
9889 }
9890
9891 if !dara.IsNil(request.Type) {
9892 query["Type"] = request.Type
9893 }
9894
9895 if !dara.IsNil(request.Value) {
9896 query["Value"] = request.Value
9897 }
9898
9899 if !dara.IsNil(request.Weight) {
9900 query["Weight"] = request.Weight
9901 }
9902
9903 if !dara.IsNil(request.ZoneId) {
9904 query["ZoneId"] = request.ZoneId
9905 }
9906
9907 req := &openapiutil.OpenApiRequest{
9908 Query: openapiutil.Query(query),
9909 }
9910 params := &openapiutil.Params{
9911 Action: dara.String("SearchRecursionRecords"),
9912 Version: dara.String("2015-01-09"),
9913 Protocol: dara.String("HTTPS"),
9914 Pathname: dara.String("/"),
9915 Method: dara.String("POST"),
9916 AuthType: dara.String("AK"),
9917 Style: dara.String("RPC"),
9918 ReqBodyType: dara.String("formData"),
9919 BodyType: dara.String("json"),
9920 }
9921 _result = &SearchRecursionRecordsResponse{}
9922 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9923 if _err != nil {
9924 return _result, _err
9925 }
9926 _err = dara.Convert(_body, &_result)
9927 return _result, _err
9928 }
9929
9930 // Summary:
9931 //
9932 // 搜索递归解析内置权威域名zone
9933 //
9934 // @param tmpReq - SearchRecursionZonesRequest
9935 //
9936 // @param runtime - runtime options for this request RuntimeOptions
9937 //
9938 // @return SearchRecursionZonesResponse
9939 func SearchRecursionZonesWithContext(ctx context.Context, client *Client, tmpReq *SearchRecursionZonesRequest, runtime *dara.RuntimeOptions) (_result *SearchRecursionZonesResponse, _err error) {
9940 if dara.BoolValue(client.EnableValidate) == true {
9941 _err = tmpReq.Validate()
9942 if _err != nil {
9943 return _result, _err
9944 }
9945 }
9946 request := &SearchRecursionZonesShrinkRequest{}
9947 openapiutil.Convert(tmpReq, request)
9948 if !dara.IsNil(tmpReq.EffectiveScopes) {
9949 request.EffectiveScopesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.EffectiveScopes, dara.String("EffectiveScopes"), dara.String("json"))
9950 }
9951
9952 query := map[string]interface{}{}
9953 if !dara.IsNil(request.Direction) {
9954 query["Direction"] = request.Direction
9955 }
9956
9957 if !dara.IsNil(request.EffectiveScopesShrink) {
9958 query["EffectiveScopes"] = request.EffectiveScopesShrink
9959 }
9960
9961 if !dara.IsNil(request.MaxResults) {
9962 query["MaxResults"] = request.MaxResults
9963 }
9964
9965 if !dara.IsNil(request.NextToken) {
9966 query["NextToken"] = request.NextToken
9967 }
9968
9969 if !dara.IsNil(request.OrderBy) {
9970 query["OrderBy"] = request.OrderBy
9971 }
9972
9973 if !dara.IsNil(request.PageNumber) {
9974 query["PageNumber"] = request.PageNumber
9975 }
9976
9977 if !dara.IsNil(request.PageSize) {
9978 query["PageSize"] = request.PageSize
9979 }
9980
9981 if !dara.IsNil(request.Remark) {
9982 query["Remark"] = request.Remark
9983 }
9984
9985 if !dara.IsNil(request.ZoneName) {
9986 query["ZoneName"] = request.ZoneName
9987 }
9988
9989 req := &openapiutil.OpenApiRequest{
9990 Query: openapiutil.Query(query),
9991 }
9992 params := &openapiutil.Params{
9993 Action: dara.String("SearchRecursionZones"),
9994 Version: dara.String("2015-01-09"),
9995 Protocol: dara.String("HTTPS"),
9996 Pathname: dara.String("/"),
9997 Method: dara.String("POST"),
9998 AuthType: dara.String("AK"),
9999 Style: dara.String("RPC"),
10000 ReqBodyType: dara.String("formData"),
10001 BodyType: dara.String("json"),
10002 }
10003 _result = &SearchRecursionZonesResponse{}
10004 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10005 if _err != nil {
10006 return _result, _err
10007 }
10008 _err = dara.Convert(_body, &_result)
10009 return _result, _err
10010 }
10011
10012 // Summary:
10013 //
10014 // Enables or disables weighted round-robin based on the specified parameters.
10015 //
10016 // @param request - SetDNSSLBStatusRequest
10017 //
10018 // @param runtime - runtime options for this request RuntimeOptions
10019 //
10020 // @return SetDNSSLBStatusResponse
10021 func SetDNSSLBStatusWithContext(ctx context.Context, client *Client, request *SetDNSSLBStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDNSSLBStatusResponse, _err error) {
10022 if dara.BoolValue(client.EnableValidate) == true {
10023 _err = request.Validate()
10024 if _err != nil {
10025 return _result, _err
10026 }
10027 }
10028 query := map[string]interface{}{}
10029 if !dara.IsNil(request.DomainName) {
10030 query["DomainName"] = request.DomainName
10031 }
10032
10033 if !dara.IsNil(request.Lang) {
10034 query["Lang"] = request.Lang
10035 }
10036
10037 if !dara.IsNil(request.Line) {
10038 query["Line"] = request.Line
10039 }
10040
10041 if !dara.IsNil(request.Open) {
10042 query["Open"] = request.Open
10043 }
10044
10045 if !dara.IsNil(request.SubDomain) {
10046 query["SubDomain"] = request.SubDomain
10047 }
10048
10049 if !dara.IsNil(request.Type) {
10050 query["Type"] = request.Type
10051 }
10052
10053 if !dara.IsNil(request.UserClientIp) {
10054 query["UserClientIp"] = request.UserClientIp
10055 }
10056
10057 req := &openapiutil.OpenApiRequest{
10058 Query: openapiutil.Query(query),
10059 }
10060 params := &openapiutil.Params{
10061 Action: dara.String("SetDNSSLBStatus"),
10062 Version: dara.String("2015-01-09"),
10063 Protocol: dara.String("HTTPS"),
10064 Pathname: dara.String("/"),
10065 Method: dara.String("POST"),
10066 AuthType: dara.String("AK"),
10067 Style: dara.String("RPC"),
10068 ReqBodyType: dara.String("formData"),
10069 BodyType: dara.String("json"),
10070 }
10071 _result = &SetDNSSLBStatusResponse{}
10072 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10073 if _err != nil {
10074 return _result, _err
10075 }
10076 _err = dara.Convert(_body, &_result)
10077 return _result, _err
10078 }
10079
10080 // Summary:
10081 //
10082 // Modifies an access policy.
10083 //
10084 // Description:
10085 //
10086 // ***
10087 //
10088 // @param request - SetDnsGtmAccessModeRequest
10089 //
10090 // @param runtime - runtime options for this request RuntimeOptions
10091 //
10092 // @return SetDnsGtmAccessModeResponse
10093 func SetDnsGtmAccessModeWithContext(ctx context.Context, client *Client, request *SetDnsGtmAccessModeRequest, runtime *dara.RuntimeOptions) (_result *SetDnsGtmAccessModeResponse, _err error) {
10094 if dara.BoolValue(client.EnableValidate) == true {
10095 _err = request.Validate()
10096 if _err != nil {
10097 return _result, _err
10098 }
10099 }
10100 query := map[string]interface{}{}
10101 if !dara.IsNil(request.AccessMode) {
10102 query["AccessMode"] = request.AccessMode
10103 }
10104
10105 if !dara.IsNil(request.Lang) {
10106 query["Lang"] = request.Lang
10107 }
10108
10109 if !dara.IsNil(request.StrategyId) {
10110 query["StrategyId"] = request.StrategyId
10111 }
10112
10113 req := &openapiutil.OpenApiRequest{
10114 Query: openapiutil.Query(query),
10115 }
10116 params := &openapiutil.Params{
10117 Action: dara.String("SetDnsGtmAccessMode"),
10118 Version: dara.String("2015-01-09"),
10119 Protocol: dara.String("HTTPS"),
10120 Pathname: dara.String("/"),
10121 Method: dara.String("POST"),
10122 AuthType: dara.String("AK"),
10123 Style: dara.String("RPC"),
10124 ReqBodyType: dara.String("formData"),
10125 BodyType: dara.String("json"),
10126 }
10127 _result = &SetDnsGtmAccessModeResponse{}
10128 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10129 if _err != nil {
10130 return _result, _err
10131 }
10132 _err = dara.Convert(_body, &_result)
10133 return _result, _err
10134 }
10135
10136 // Summary:
10137 //
10138 // Specifies the health check status of an address pool.
10139 //
10140 // @param request - SetDnsGtmMonitorStatusRequest
10141 //
10142 // @param runtime - runtime options for this request RuntimeOptions
10143 //
10144 // @return SetDnsGtmMonitorStatusResponse
10145 func SetDnsGtmMonitorStatusWithContext(ctx context.Context, client *Client, request *SetDnsGtmMonitorStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDnsGtmMonitorStatusResponse, _err error) {
10146 if dara.BoolValue(client.EnableValidate) == true {
10147 _err = request.Validate()
10148 if _err != nil {
10149 return _result, _err
10150 }
10151 }
10152 query := map[string]interface{}{}
10153 if !dara.IsNil(request.Lang) {
10154 query["Lang"] = request.Lang
10155 }
10156
10157 if !dara.IsNil(request.MonitorConfigId) {
10158 query["MonitorConfigId"] = request.MonitorConfigId
10159 }
10160
10161 if !dara.IsNil(request.Status) {
10162 query["Status"] = request.Status
10163 }
10164
10165 req := &openapiutil.OpenApiRequest{
10166 Query: openapiutil.Query(query),
10167 }
10168 params := &openapiutil.Params{
10169 Action: dara.String("SetDnsGtmMonitorStatus"),
10170 Version: dara.String("2015-01-09"),
10171 Protocol: dara.String("HTTPS"),
10172 Pathname: dara.String("/"),
10173 Method: dara.String("POST"),
10174 AuthType: dara.String("AK"),
10175 Style: dara.String("RPC"),
10176 ReqBodyType: dara.String("formData"),
10177 BodyType: dara.String("json"),
10178 }
10179 _result = &SetDnsGtmMonitorStatusResponse{}
10180 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10181 if _err != nil {
10182 return _result, _err
10183 }
10184 _err = dara.Convert(_body, &_result)
10185 return _result, _err
10186 }
10187
10188 // Summary:
10189 //
10190 // 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.
10191 //
10192 // @param request - SetDomainDnssecStatusRequest
10193 //
10194 // @param runtime - runtime options for this request RuntimeOptions
10195 //
10196 // @return SetDomainDnssecStatusResponse
10197 func SetDomainDnssecStatusWithContext(ctx context.Context, client *Client, request *SetDomainDnssecStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDomainDnssecStatusResponse, _err error) {
10198 if dara.BoolValue(client.EnableValidate) == true {
10199 _err = request.Validate()
10200 if _err != nil {
10201 return _result, _err
10202 }
10203 }
10204 query := map[string]interface{}{}
10205 if !dara.IsNil(request.DomainName) {
10206 query["DomainName"] = request.DomainName
10207 }
10208
10209 if !dara.IsNil(request.Lang) {
10210 query["Lang"] = request.Lang
10211 }
10212
10213 if !dara.IsNil(request.Status) {
10214 query["Status"] = request.Status
10215 }
10216
10217 req := &openapiutil.OpenApiRequest{
10218 Query: openapiutil.Query(query),
10219 }
10220 params := &openapiutil.Params{
10221 Action: dara.String("SetDomainDnssecStatus"),
10222 Version: dara.String("2015-01-09"),
10223 Protocol: dara.String("HTTPS"),
10224 Pathname: dara.String("/"),
10225 Method: dara.String("POST"),
10226 AuthType: dara.String("AK"),
10227 Style: dara.String("RPC"),
10228 ReqBodyType: dara.String("formData"),
10229 BodyType: dara.String("json"),
10230 }
10231 _result = &SetDomainDnssecStatusResponse{}
10232 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10233 if _err != nil {
10234 return _result, _err
10235 }
10236 _err = dara.Convert(_body, &_result)
10237 return _result, _err
10238 }
10239
10240 // Summary:
10241 //
10242 // Specifies the status of an Alibaba Cloud DNS (DNS) record based on the specified parameters.
10243 //
10244 // @param request - SetDomainRecordStatusRequest
10245 //
10246 // @param runtime - runtime options for this request RuntimeOptions
10247 //
10248 // @return SetDomainRecordStatusResponse
10249 func SetDomainRecordStatusWithContext(ctx context.Context, client *Client, request *SetDomainRecordStatusRequest, runtime *dara.RuntimeOptions) (_result *SetDomainRecordStatusResponse, _err error) {
10250 if dara.BoolValue(client.EnableValidate) == true {
10251 _err = request.Validate()
10252 if _err != nil {
10253 return _result, _err
10254 }
10255 }
10256 query := map[string]interface{}{}
10257 if !dara.IsNil(request.Lang) {
10258 query["Lang"] = request.Lang
10259 }
10260
10261 if !dara.IsNil(request.RecordId) {
10262 query["RecordId"] = request.RecordId
10263 }
10264
10265 if !dara.IsNil(request.Status) {
10266 query["Status"] = request.Status
10267 }
10268
10269 if !dara.IsNil(request.UserClientIp) {
10270 query["UserClientIp"] = request.UserClientIp
10271 }
10272
10273 req := &openapiutil.OpenApiRequest{
10274 Query: openapiutil.Query(query),
10275 }
10276 params := &openapiutil.Params{
10277 Action: dara.String("SetDomainRecordStatus"),
10278 Version: dara.String("2015-01-09"),
10279 Protocol: dara.String("HTTPS"),
10280 Pathname: dara.String("/"),
10281 Method: dara.String("POST"),
10282 AuthType: dara.String("AK"),
10283 Style: dara.String("RPC"),
10284 ReqBodyType: dara.String("formData"),
10285 BodyType: dara.String("json"),
10286 }
10287 _result = &SetDomainRecordStatusResponse{}
10288 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10289 if _err != nil {
10290 return _result, _err
10291 }
10292 _err = dara.Convert(_body, &_result)
10293 return _result, _err
10294 }
10295
10296 // Summary:
10297 //
10298 // Modifies a policy for switchover between address pool sets.
10299 //
10300 // @param request - SetGtmAccessModeRequest
10301 //
10302 // @param runtime - runtime options for this request RuntimeOptions
10303 //
10304 // @return SetGtmAccessModeResponse
10305 func SetGtmAccessModeWithContext(ctx context.Context, client *Client, request *SetGtmAccessModeRequest, runtime *dara.RuntimeOptions) (_result *SetGtmAccessModeResponse, _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.AccessMode) {
10314 query["AccessMode"] = request.AccessMode
10315 }
10316
10317 if !dara.IsNil(request.Lang) {
10318 query["Lang"] = request.Lang
10319 }
10320
10321 if !dara.IsNil(request.StrategyId) {
10322 query["StrategyId"] = request.StrategyId
10323 }
10324
10325 req := &openapiutil.OpenApiRequest{
10326 Query: openapiutil.Query(query),
10327 }
10328 params := &openapiutil.Params{
10329 Action: dara.String("SetGtmAccessMode"),
10330 Version: dara.String("2015-01-09"),
10331 Protocol: dara.String("HTTPS"),
10332 Pathname: dara.String("/"),
10333 Method: dara.String("POST"),
10334 AuthType: dara.String("AK"),
10335 Style: dara.String("RPC"),
10336 ReqBodyType: dara.String("formData"),
10337 BodyType: dara.String("json"),
10338 }
10339 _result = &SetGtmAccessModeResponse{}
10340 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10341 if _err != nil {
10342 return _result, _err
10343 }
10344 _err = dara.Convert(_body, &_result)
10345 return _result, _err
10346 }
10347
10348 // @param request - SetGtmMonitorStatusRequest
10349 //
10350 // @param runtime - runtime options for this request RuntimeOptions
10351 //
10352 // @return SetGtmMonitorStatusResponse
10353 func SetGtmMonitorStatusWithContext(ctx context.Context, client *Client, request *SetGtmMonitorStatusRequest, runtime *dara.RuntimeOptions) (_result *SetGtmMonitorStatusResponse, _err error) {
10354 if dara.BoolValue(client.EnableValidate) == true {
10355 _err = request.Validate()
10356 if _err != nil {
10357 return _result, _err
10358 }
10359 }
10360 query := map[string]interface{}{}
10361 if !dara.IsNil(request.Lang) {
10362 query["Lang"] = request.Lang
10363 }
10364
10365 if !dara.IsNil(request.MonitorConfigId) {
10366 query["MonitorConfigId"] = request.MonitorConfigId
10367 }
10368
10369 if !dara.IsNil(request.Status) {
10370 query["Status"] = request.Status
10371 }
10372
10373 req := &openapiutil.OpenApiRequest{
10374 Query: openapiutil.Query(query),
10375 }
10376 params := &openapiutil.Params{
10377 Action: dara.String("SetGtmMonitorStatus"),
10378 Version: dara.String("2015-01-09"),
10379 Protocol: dara.String("HTTPS"),
10380 Pathname: dara.String("/"),
10381 Method: dara.String("POST"),
10382 AuthType: dara.String("AK"),
10383 Style: dara.String("RPC"),
10384 ReqBodyType: dara.String("formData"),
10385 BodyType: dara.String("json"),
10386 }
10387 _result = &SetGtmMonitorStatusResponse{}
10388 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10389 if _err != nil {
10390 return _result, _err
10391 }
10392 _err = dara.Convert(_body, &_result)
10393 return _result, _err
10394 }
10395
10396 // Summary:
10397 //
10398 // 提交缓存刷新任务
10399 //
10400 // @param request - SubmitIspFlushCacheTaskRequest
10401 //
10402 // @param runtime - runtime options for this request RuntimeOptions
10403 //
10404 // @return SubmitIspFlushCacheTaskResponse
10405 func SubmitIspFlushCacheTaskWithContext(ctx context.Context, client *Client, request *SubmitIspFlushCacheTaskRequest, runtime *dara.RuntimeOptions) (_result *SubmitIspFlushCacheTaskResponse, _err error) {
10406 if dara.BoolValue(client.EnableValidate) == true {
10407 _err = request.Validate()
10408 if _err != nil {
10409 return _result, _err
10410 }
10411 }
10412 query := map[string]interface{}{}
10413 if !dara.IsNil(request.ClientToken) {
10414 query["ClientToken"] = request.ClientToken
10415 }
10416
10417 if !dara.IsNil(request.DomainName) {
10418 query["DomainName"] = request.DomainName
10419 }
10420
10421 if !dara.IsNil(request.Isp) {
10422 query["Isp"] = request.Isp
10423 }
10424
10425 if !dara.IsNil(request.Lang) {
10426 query["Lang"] = request.Lang
10427 }
10428
10429 req := &openapiutil.OpenApiRequest{
10430 Query: openapiutil.Query(query),
10431 }
10432 params := &openapiutil.Params{
10433 Action: dara.String("SubmitIspFlushCacheTask"),
10434 Version: dara.String("2015-01-09"),
10435 Protocol: dara.String("HTTPS"),
10436 Pathname: dara.String("/"),
10437 Method: dara.String("POST"),
10438 AuthType: dara.String("AK"),
10439 Style: dara.String("RPC"),
10440 ReqBodyType: dara.String("formData"),
10441 BodyType: dara.String("json"),
10442 }
10443 _result = &SubmitIspFlushCacheTaskResponse{}
10444 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10445 if _err != nil {
10446 return _result, _err
10447 }
10448 _err = dara.Convert(_body, &_result)
10449 return _result, _err
10450 }
10451
10452 // Summary:
10453 //
10454 // Changes the access policy type for a Global Traffic Manager (GTM) instance.
10455 //
10456 // @param request - SwitchDnsGtmInstanceStrategyModeRequest
10457 //
10458 // @param runtime - runtime options for this request RuntimeOptions
10459 //
10460 // @return SwitchDnsGtmInstanceStrategyModeResponse
10461 func SwitchDnsGtmInstanceStrategyModeWithContext(ctx context.Context, client *Client, request *SwitchDnsGtmInstanceStrategyModeRequest, runtime *dara.RuntimeOptions) (_result *SwitchDnsGtmInstanceStrategyModeResponse, _err error) {
10462 if dara.BoolValue(client.EnableValidate) == true {
10463 _err = request.Validate()
10464 if _err != nil {
10465 return _result, _err
10466 }
10467 }
10468 query := map[string]interface{}{}
10469 if !dara.IsNil(request.InstanceId) {
10470 query["InstanceId"] = request.InstanceId
10471 }
10472
10473 if !dara.IsNil(request.Lang) {
10474 query["Lang"] = request.Lang
10475 }
10476
10477 if !dara.IsNil(request.StrategyMode) {
10478 query["StrategyMode"] = request.StrategyMode
10479 }
10480
10481 req := &openapiutil.OpenApiRequest{
10482 Query: openapiutil.Query(query),
10483 }
10484 params := &openapiutil.Params{
10485 Action: dara.String("SwitchDnsGtmInstanceStrategyMode"),
10486 Version: dara.String("2015-01-09"),
10487 Protocol: dara.String("HTTPS"),
10488 Pathname: dara.String("/"),
10489 Method: dara.String("POST"),
10490 AuthType: dara.String("AK"),
10491 Style: dara.String("RPC"),
10492 ReqBodyType: dara.String("formData"),
10493 BodyType: dara.String("json"),
10494 }
10495 _result = &SwitchDnsGtmInstanceStrategyModeResponse{}
10496 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10497 if _err != nil {
10498 return _result, _err
10499 }
10500 _err = dara.Convert(_body, &_result)
10501 return _result, _err
10502 }
10503
10504 // Summary:
10505 //
10506 // Adds and modifies a tag for a resource.
10507 //
10508 // @param request - TagResourcesRequest
10509 //
10510 // @param runtime - runtime options for this request RuntimeOptions
10511 //
10512 // @return TagResourcesResponse
10513 func TagResourcesWithContext(ctx context.Context, client *Client, request *TagResourcesRequest, runtime *dara.RuntimeOptions) (_result *TagResourcesResponse, _err error) {
10514 if dara.BoolValue(client.EnableValidate) == true {
10515 _err = request.Validate()
10516 if _err != nil {
10517 return _result, _err
10518 }
10519 }
10520 query := map[string]interface{}{}
10521 if !dara.IsNil(request.Lang) {
10522 query["Lang"] = request.Lang
10523 }
10524
10525 if !dara.IsNil(request.ResourceId) {
10526 query["ResourceId"] = request.ResourceId
10527 }
10528
10529 if !dara.IsNil(request.ResourceType) {
10530 query["ResourceType"] = request.ResourceType
10531 }
10532
10533 if !dara.IsNil(request.Tag) {
10534 query["Tag"] = request.Tag
10535 }
10536
10537 req := &openapiutil.OpenApiRequest{
10538 Query: openapiutil.Query(query),
10539 }
10540 params := &openapiutil.Params{
10541 Action: dara.String("TagResources"),
10542 Version: dara.String("2015-01-09"),
10543 Protocol: dara.String("HTTPS"),
10544 Pathname: dara.String("/"),
10545 Method: dara.String("POST"),
10546 AuthType: dara.String("AK"),
10547 Style: dara.String("RPC"),
10548 ReqBodyType: dara.String("formData"),
10549 BodyType: dara.String("json"),
10550 }
10551 _result = &TagResourcesResponse{}
10552 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10553 if _err != nil {
10554 return _result, _err
10555 }
10556 _err = dara.Convert(_body, &_result)
10557 return _result, _err
10558 }
10559
10560 // Summary:
10561 //
10562 // Transfers multiple domain names from the current account to another account at a time.
10563 //
10564 // @param request - TransferDomainRequest
10565 //
10566 // @param runtime - runtime options for this request RuntimeOptions
10567 //
10568 // @return TransferDomainResponse
10569 func TransferDomainWithContext(ctx context.Context, client *Client, request *TransferDomainRequest, runtime *dara.RuntimeOptions) (_result *TransferDomainResponse, _err error) {
10570 if dara.BoolValue(client.EnableValidate) == true {
10571 _err = request.Validate()
10572 if _err != nil {
10573 return _result, _err
10574 }
10575 }
10576 query := map[string]interface{}{}
10577 if !dara.IsNil(request.DomainNames) {
10578 query["DomainNames"] = request.DomainNames
10579 }
10580
10581 if !dara.IsNil(request.Lang) {
10582 query["Lang"] = request.Lang
10583 }
10584
10585 if !dara.IsNil(request.Remark) {
10586 query["Remark"] = request.Remark
10587 }
10588
10589 if !dara.IsNil(request.TargetUserId) {
10590 query["TargetUserId"] = request.TargetUserId
10591 }
10592
10593 req := &openapiutil.OpenApiRequest{
10594 Query: openapiutil.Query(query),
10595 }
10596 params := &openapiutil.Params{
10597 Action: dara.String("TransferDomain"),
10598 Version: dara.String("2015-01-09"),
10599 Protocol: dara.String("HTTPS"),
10600 Pathname: dara.String("/"),
10601 Method: dara.String("POST"),
10602 AuthType: dara.String("AK"),
10603 Style: dara.String("RPC"),
10604 ReqBodyType: dara.String("formData"),
10605 BodyType: dara.String("json"),
10606 }
10607 _result = &TransferDomainResponse{}
10608 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10609 if _err != nil {
10610 return _result, _err
10611 }
10612 _err = dara.Convert(_body, &_result)
10613 return _result, _err
10614 }
10615
10616 // Summary:
10617 //
10618 // Unbinds one or more domain names from a paid Alibaba Cloud DNS instance based on the instance ID.
10619 //
10620 // Description:
10621 //
10622 // 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.\\
10623 //
10624 // 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.
10625 //
10626 // @param request - UnbindInstanceDomainsRequest
10627 //
10628 // @param runtime - runtime options for this request RuntimeOptions
10629 //
10630 // @return UnbindInstanceDomainsResponse
10631 func UnbindInstanceDomainsWithContext(ctx context.Context, client *Client, request *UnbindInstanceDomainsRequest, runtime *dara.RuntimeOptions) (_result *UnbindInstanceDomainsResponse, _err error) {
10632 if dara.BoolValue(client.EnableValidate) == true {
10633 _err = request.Validate()
10634 if _err != nil {
10635 return _result, _err
10636 }
10637 }
10638 query := map[string]interface{}{}
10639 if !dara.IsNil(request.DomainNames) {
10640 query["DomainNames"] = request.DomainNames
10641 }
10642
10643 if !dara.IsNil(request.InstanceId) {
10644 query["InstanceId"] = request.InstanceId
10645 }
10646
10647 if !dara.IsNil(request.Lang) {
10648 query["Lang"] = request.Lang
10649 }
10650
10651 req := &openapiutil.OpenApiRequest{
10652 Query: openapiutil.Query(query),
10653 }
10654 params := &openapiutil.Params{
10655 Action: dara.String("UnbindInstanceDomains"),
10656 Version: dara.String("2015-01-09"),
10657 Protocol: dara.String("HTTPS"),
10658 Pathname: dara.String("/"),
10659 Method: dara.String("POST"),
10660 AuthType: dara.String("AK"),
10661 Style: dara.String("RPC"),
10662 ReqBodyType: dara.String("formData"),
10663 BodyType: dara.String("json"),
10664 }
10665 _result = &UnbindInstanceDomainsResponse{}
10666 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10667 if _err != nil {
10668 return _result, _err
10669 }
10670 _err = dara.Convert(_body, &_result)
10671 return _result, _err
10672 }
10673
10674 // Summary:
10675 //
10676 // Removes tags from resources.
10677 //
10678 // @param request - UntagResourcesRequest
10679 //
10680 // @param runtime - runtime options for this request RuntimeOptions
10681 //
10682 // @return UntagResourcesResponse
10683 func UntagResourcesWithContext(ctx context.Context, client *Client, request *UntagResourcesRequest, runtime *dara.RuntimeOptions) (_result *UntagResourcesResponse, _err error) {
10684 if dara.BoolValue(client.EnableValidate) == true {
10685 _err = request.Validate()
10686 if _err != nil {
10687 return _result, _err
10688 }
10689 }
10690 query := map[string]interface{}{}
10691 if !dara.IsNil(request.All) {
10692 query["All"] = request.All
10693 }
10694
10695 if !dara.IsNil(request.Lang) {
10696 query["Lang"] = request.Lang
10697 }
10698
10699 if !dara.IsNil(request.ResourceId) {
10700 query["ResourceId"] = request.ResourceId
10701 }
10702
10703 if !dara.IsNil(request.ResourceType) {
10704 query["ResourceType"] = request.ResourceType
10705 }
10706
10707 if !dara.IsNil(request.TagKey) {
10708 query["TagKey"] = request.TagKey
10709 }
10710
10711 req := &openapiutil.OpenApiRequest{
10712 Query: openapiutil.Query(query),
10713 }
10714 params := &openapiutil.Params{
10715 Action: dara.String("UntagResources"),
10716 Version: dara.String("2015-01-09"),
10717 Protocol: dara.String("HTTPS"),
10718 Pathname: dara.String("/"),
10719 Method: dara.String("POST"),
10720 AuthType: dara.String("AK"),
10721 Style: dara.String("RPC"),
10722 ReqBodyType: dara.String("formData"),
10723 BodyType: dara.String("json"),
10724 }
10725 _result = &UntagResourcesResponse{}
10726 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10727 if _err != nil {
10728 return _result, _err
10729 }
10730 _err = dara.Convert(_body, &_result)
10731 return _result, _err
10732 }
10733
10734 // Summary:
10735 //
10736 // 修改 AppKey 状态
10737 //
10738 // @param request - UpdateAppKeyStateRequest
10739 //
10740 // @param runtime - runtime options for this request RuntimeOptions
10741 //
10742 // @return UpdateAppKeyStateResponse
10743 func UpdateAppKeyStateWithContext(ctx context.Context, client *Client, request *UpdateAppKeyStateRequest, runtime *dara.RuntimeOptions) (_result *UpdateAppKeyStateResponse, _err error) {
10744 if dara.BoolValue(client.EnableValidate) == true {
10745 _err = request.Validate()
10746 if _err != nil {
10747 return _result, _err
10748 }
10749 }
10750 query := map[string]interface{}{}
10751 if !dara.IsNil(request.AppKeyId) {
10752 query["AppKeyId"] = request.AppKeyId
10753 }
10754
10755 if !dara.IsNil(request.Lang) {
10756 query["Lang"] = request.Lang
10757 }
10758
10759 if !dara.IsNil(request.State) {
10760 query["State"] = request.State
10761 }
10762
10763 req := &openapiutil.OpenApiRequest{
10764 Query: openapiutil.Query(query),
10765 }
10766 params := &openapiutil.Params{
10767 Action: dara.String("UpdateAppKeyState"),
10768 Version: dara.String("2015-01-09"),
10769 Protocol: dara.String("HTTPS"),
10770 Pathname: dara.String("/"),
10771 Method: dara.String("POST"),
10772 AuthType: dara.String("AK"),
10773 Style: dara.String("RPC"),
10774 ReqBodyType: dara.String("formData"),
10775 BodyType: dara.String("json"),
10776 }
10777 _result = &UpdateAppKeyStateResponse{}
10778 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10779 if _err != nil {
10780 return _result, _err
10781 }
10782 _err = dara.Convert(_body, &_result)
10783 return _result, _err
10784 }
10785
10786 // Summary:
10787 //
10788 // Modifies the condition for determining the health status of a specified address.
10789 //
10790 // @param tmpReq - UpdateCloudGtmAddressRequest
10791 //
10792 // @param runtime - runtime options for this request RuntimeOptions
10793 //
10794 // @return UpdateCloudGtmAddressResponse
10795 func UpdateCloudGtmAddressWithContext(ctx context.Context, client *Client, tmpReq *UpdateCloudGtmAddressRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressResponse, _err error) {
10796 if dara.BoolValue(client.EnableValidate) == true {
10797 _err = tmpReq.Validate()
10798 if _err != nil {
10799 return _result, _err
10800 }
10801 }
10802 request := &UpdateCloudGtmAddressShrinkRequest{}
10803 openapiutil.Convert(tmpReq, request)
10804 if !dara.IsNil(tmpReq.HealthTasks) {
10805 request.HealthTasksShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HealthTasks, dara.String("HealthTasks"), dara.String("json"))
10806 }
10807
10808 query := map[string]interface{}{}
10809 if !dara.IsNil(request.AcceptLanguage) {
10810 query["AcceptLanguage"] = request.AcceptLanguage
10811 }
10812
10813 if !dara.IsNil(request.Address) {
10814 query["Address"] = request.Address
10815 }
10816
10817 if !dara.IsNil(request.AddressId) {
10818 query["AddressId"] = request.AddressId
10819 }
10820
10821 if !dara.IsNil(request.AttributeInfo) {
10822 query["AttributeInfo"] = request.AttributeInfo
10823 }
10824
10825 if !dara.IsNil(request.ClientToken) {
10826 query["ClientToken"] = request.ClientToken
10827 }
10828
10829 if !dara.IsNil(request.HealthJudgement) {
10830 query["HealthJudgement"] = request.HealthJudgement
10831 }
10832
10833 if !dara.IsNil(request.HealthTasksShrink) {
10834 query["HealthTasks"] = request.HealthTasksShrink
10835 }
10836
10837 if !dara.IsNil(request.Name) {
10838 query["Name"] = request.Name
10839 }
10840
10841 req := &openapiutil.OpenApiRequest{
10842 Query: openapiutil.Query(query),
10843 }
10844 params := &openapiutil.Params{
10845 Action: dara.String("UpdateCloudGtmAddress"),
10846 Version: dara.String("2015-01-09"),
10847 Protocol: dara.String("HTTPS"),
10848 Pathname: dara.String("/"),
10849 Method: dara.String("POST"),
10850 AuthType: dara.String("AK"),
10851 Style: dara.String("RPC"),
10852 ReqBodyType: dara.String("formData"),
10853 BodyType: dara.String("json"),
10854 }
10855 _result = &UpdateCloudGtmAddressResponse{}
10856 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10857 if _err != nil {
10858 return _result, _err
10859 }
10860 _err = dara.Convert(_body, &_result)
10861 return _result, _err
10862 }
10863
10864 // Summary:
10865 //
10866 // Modifies the enabling status of an address.
10867 //
10868 // Description:
10869 //
10870 // If an address is **enabled* - and the health status of the address is **Normal**, the availability status of the address is **Available**.
10871 //
10872 // - If an address is **disabled* - or the health status of the address is **Abnormal**, the availability status of the address is **Unavailable**.
10873 //
10874 // @param request - UpdateCloudGtmAddressEnableStatusRequest
10875 //
10876 // @param runtime - runtime options for this request RuntimeOptions
10877 //
10878 // @return UpdateCloudGtmAddressEnableStatusResponse
10879 func UpdateCloudGtmAddressEnableStatusWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressEnableStatusResponse, _err error) {
10880 if dara.BoolValue(client.EnableValidate) == true {
10881 _err = request.Validate()
10882 if _err != nil {
10883 return _result, _err
10884 }
10885 }
10886 query := map[string]interface{}{}
10887 if !dara.IsNil(request.AcceptLanguage) {
10888 query["AcceptLanguage"] = request.AcceptLanguage
10889 }
10890
10891 if !dara.IsNil(request.AddressId) {
10892 query["AddressId"] = request.AddressId
10893 }
10894
10895 if !dara.IsNil(request.ClientToken) {
10896 query["ClientToken"] = request.ClientToken
10897 }
10898
10899 if !dara.IsNil(request.EnableStatus) {
10900 query["EnableStatus"] = request.EnableStatus
10901 }
10902
10903 req := &openapiutil.OpenApiRequest{
10904 Query: openapiutil.Query(query),
10905 }
10906 params := &openapiutil.Params{
10907 Action: dara.String("UpdateCloudGtmAddressEnableStatus"),
10908 Version: dara.String("2015-01-09"),
10909 Protocol: dara.String("HTTPS"),
10910 Pathname: dara.String("/"),
10911 Method: dara.String("POST"),
10912 AuthType: dara.String("AK"),
10913 Style: dara.String("RPC"),
10914 ReqBodyType: dara.String("formData"),
10915 BodyType: dara.String("json"),
10916 }
10917 _result = &UpdateCloudGtmAddressEnableStatusResponse{}
10918 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10919 if _err != nil {
10920 return _result, _err
10921 }
10922 _err = dara.Convert(_body, &_result)
10923 return _result, _err
10924 }
10925
10926 // Summary:
10927 //
10928 // Modifies the failover mode that is used when address exceptions are identified.
10929 //
10930 // @param request - UpdateCloudGtmAddressManualAvailableStatusRequest
10931 //
10932 // @param runtime - runtime options for this request RuntimeOptions
10933 //
10934 // @return UpdateCloudGtmAddressManualAvailableStatusResponse
10935 func UpdateCloudGtmAddressManualAvailableStatusWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressManualAvailableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressManualAvailableStatusResponse, _err error) {
10936 if dara.BoolValue(client.EnableValidate) == true {
10937 _err = request.Validate()
10938 if _err != nil {
10939 return _result, _err
10940 }
10941 }
10942 query := map[string]interface{}{}
10943 if !dara.IsNil(request.AcceptLanguage) {
10944 query["AcceptLanguage"] = request.AcceptLanguage
10945 }
10946
10947 if !dara.IsNil(request.AddressId) {
10948 query["AddressId"] = request.AddressId
10949 }
10950
10951 if !dara.IsNil(request.AvailableMode) {
10952 query["AvailableMode"] = request.AvailableMode
10953 }
10954
10955 if !dara.IsNil(request.ClientToken) {
10956 query["ClientToken"] = request.ClientToken
10957 }
10958
10959 if !dara.IsNil(request.ManualAvailableStatus) {
10960 query["ManualAvailableStatus"] = request.ManualAvailableStatus
10961 }
10962
10963 req := &openapiutil.OpenApiRequest{
10964 Query: openapiutil.Query(query),
10965 }
10966 params := &openapiutil.Params{
10967 Action: dara.String("UpdateCloudGtmAddressManualAvailableStatus"),
10968 Version: dara.String("2015-01-09"),
10969 Protocol: dara.String("HTTPS"),
10970 Pathname: dara.String("/"),
10971 Method: dara.String("POST"),
10972 AuthType: dara.String("AK"),
10973 Style: dara.String("RPC"),
10974 ReqBodyType: dara.String("formData"),
10975 BodyType: dara.String("json"),
10976 }
10977 _result = &UpdateCloudGtmAddressManualAvailableStatusResponse{}
10978 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10979 if _err != nil {
10980 return _result, _err
10981 }
10982 _err = dara.Convert(_body, &_result)
10983 return _result, _err
10984 }
10985
10986 // Summary:
10987 //
10988 // Modifies the basic configurations of an address pool.
10989 //
10990 // @param request - UpdateCloudGtmAddressPoolBasicConfigRequest
10991 //
10992 // @param runtime - runtime options for this request RuntimeOptions
10993 //
10994 // @return UpdateCloudGtmAddressPoolBasicConfigResponse
10995 func UpdateCloudGtmAddressPoolBasicConfigWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressPoolBasicConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolBasicConfigResponse, _err error) {
10996 if dara.BoolValue(client.EnableValidate) == true {
10997 _err = request.Validate()
10998 if _err != nil {
10999 return _result, _err
11000 }
11001 }
11002 query := map[string]interface{}{}
11003 if !dara.IsNil(request.AcceptLanguage) {
11004 query["AcceptLanguage"] = request.AcceptLanguage
11005 }
11006
11007 if !dara.IsNil(request.AddressPoolId) {
11008 query["AddressPoolId"] = request.AddressPoolId
11009 }
11010
11011 if !dara.IsNil(request.AddressPoolName) {
11012 query["AddressPoolName"] = request.AddressPoolName
11013 }
11014
11015 if !dara.IsNil(request.ClientToken) {
11016 query["ClientToken"] = request.ClientToken
11017 }
11018
11019 if !dara.IsNil(request.HealthJudgement) {
11020 query["HealthJudgement"] = request.HealthJudgement
11021 }
11022
11023 req := &openapiutil.OpenApiRequest{
11024 Query: openapiutil.Query(query),
11025 }
11026 params := &openapiutil.Params{
11027 Action: dara.String("UpdateCloudGtmAddressPoolBasicConfig"),
11028 Version: dara.String("2015-01-09"),
11029 Protocol: dara.String("HTTPS"),
11030 Pathname: dara.String("/"),
11031 Method: dara.String("POST"),
11032 AuthType: dara.String("AK"),
11033 Style: dara.String("RPC"),
11034 ReqBodyType: dara.String("formData"),
11035 BodyType: dara.String("json"),
11036 }
11037 _result = &UpdateCloudGtmAddressPoolBasicConfigResponse{}
11038 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11039 if _err != nil {
11040 return _result, _err
11041 }
11042 _err = dara.Convert(_body, &_result)
11043 return _result, _err
11044 }
11045
11046 // Summary:
11047 //
11048 // Modifies the enabling status of an address pool.
11049 //
11050 // Description:
11051 //
11052 // 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**.
11053 //
11054 // - 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**.
11055 //
11056 // @param request - UpdateCloudGtmAddressPoolEnableStatusRequest
11057 //
11058 // @param runtime - runtime options for this request RuntimeOptions
11059 //
11060 // @return UpdateCloudGtmAddressPoolEnableStatusResponse
11061 func UpdateCloudGtmAddressPoolEnableStatusWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressPoolEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolEnableStatusResponse, _err error) {
11062 if dara.BoolValue(client.EnableValidate) == true {
11063 _err = request.Validate()
11064 if _err != nil {
11065 return _result, _err
11066 }
11067 }
11068 query := map[string]interface{}{}
11069 if !dara.IsNil(request.AcceptLanguage) {
11070 query["AcceptLanguage"] = request.AcceptLanguage
11071 }
11072
11073 if !dara.IsNil(request.AddressPoolId) {
11074 query["AddressPoolId"] = request.AddressPoolId
11075 }
11076
11077 if !dara.IsNil(request.ClientToken) {
11078 query["ClientToken"] = request.ClientToken
11079 }
11080
11081 if !dara.IsNil(request.EnableStatus) {
11082 query["EnableStatus"] = request.EnableStatus
11083 }
11084
11085 req := &openapiutil.OpenApiRequest{
11086 Query: openapiutil.Query(query),
11087 }
11088 params := &openapiutil.Params{
11089 Action: dara.String("UpdateCloudGtmAddressPoolEnableStatus"),
11090 Version: dara.String("2015-01-09"),
11091 Protocol: dara.String("HTTPS"),
11092 Pathname: dara.String("/"),
11093 Method: dara.String("POST"),
11094 AuthType: dara.String("AK"),
11095 Style: dara.String("RPC"),
11096 ReqBodyType: dara.String("formData"),
11097 BodyType: dara.String("json"),
11098 }
11099 _result = &UpdateCloudGtmAddressPoolEnableStatusResponse{}
11100 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11101 if _err != nil {
11102 return _result, _err
11103 }
11104 _err = dara.Convert(_body, &_result)
11105 return _result, _err
11106 }
11107
11108 // Summary:
11109 //
11110 // Modifies the load balancing policy of an address pool.
11111 //
11112 // @param request - UpdateCloudGtmAddressPoolLbStrategyRequest
11113 //
11114 // @param runtime - runtime options for this request RuntimeOptions
11115 //
11116 // @return UpdateCloudGtmAddressPoolLbStrategyResponse
11117 func UpdateCloudGtmAddressPoolLbStrategyWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressPoolLbStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolLbStrategyResponse, _err error) {
11118 if dara.BoolValue(client.EnableValidate) == true {
11119 _err = request.Validate()
11120 if _err != nil {
11121 return _result, _err
11122 }
11123 }
11124 query := map[string]interface{}{}
11125 if !dara.IsNil(request.AcceptLanguage) {
11126 query["AcceptLanguage"] = request.AcceptLanguage
11127 }
11128
11129 if !dara.IsNil(request.AddressLbStrategy) {
11130 query["AddressLbStrategy"] = request.AddressLbStrategy
11131 }
11132
11133 if !dara.IsNil(request.AddressPoolId) {
11134 query["AddressPoolId"] = request.AddressPoolId
11135 }
11136
11137 if !dara.IsNil(request.ClientToken) {
11138 query["ClientToken"] = request.ClientToken
11139 }
11140
11141 if !dara.IsNil(request.SequenceLbStrategyMode) {
11142 query["SequenceLbStrategyMode"] = request.SequenceLbStrategyMode
11143 }
11144
11145 req := &openapiutil.OpenApiRequest{
11146 Query: openapiutil.Query(query),
11147 }
11148 params := &openapiutil.Params{
11149 Action: dara.String("UpdateCloudGtmAddressPoolLbStrategy"),
11150 Version: dara.String("2015-01-09"),
11151 Protocol: dara.String("HTTPS"),
11152 Pathname: dara.String("/"),
11153 Method: dara.String("POST"),
11154 AuthType: dara.String("AK"),
11155 Style: dara.String("RPC"),
11156 ReqBodyType: dara.String("formData"),
11157 BodyType: dara.String("json"),
11158 }
11159 _result = &UpdateCloudGtmAddressPoolLbStrategyResponse{}
11160 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11161 if _err != nil {
11162 return _result, _err
11163 }
11164 _err = dara.Convert(_body, &_result)
11165 return _result, _err
11166 }
11167
11168 // Summary:
11169 //
11170 // Modifies the remarks of an address pool.
11171 //
11172 // @param request - UpdateCloudGtmAddressPoolRemarkRequest
11173 //
11174 // @param runtime - runtime options for this request RuntimeOptions
11175 //
11176 // @return UpdateCloudGtmAddressPoolRemarkResponse
11177 func UpdateCloudGtmAddressPoolRemarkWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressPoolRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressPoolRemarkResponse, _err error) {
11178 if dara.BoolValue(client.EnableValidate) == true {
11179 _err = request.Validate()
11180 if _err != nil {
11181 return _result, _err
11182 }
11183 }
11184 query := map[string]interface{}{}
11185 if !dara.IsNil(request.AcceptLanguage) {
11186 query["AcceptLanguage"] = request.AcceptLanguage
11187 }
11188
11189 if !dara.IsNil(request.AddressPoolId) {
11190 query["AddressPoolId"] = request.AddressPoolId
11191 }
11192
11193 if !dara.IsNil(request.ClientToken) {
11194 query["ClientToken"] = request.ClientToken
11195 }
11196
11197 if !dara.IsNil(request.Remark) {
11198 query["Remark"] = request.Remark
11199 }
11200
11201 req := &openapiutil.OpenApiRequest{
11202 Query: openapiutil.Query(query),
11203 }
11204 params := &openapiutil.Params{
11205 Action: dara.String("UpdateCloudGtmAddressPoolRemark"),
11206 Version: dara.String("2015-01-09"),
11207 Protocol: dara.String("HTTPS"),
11208 Pathname: dara.String("/"),
11209 Method: dara.String("POST"),
11210 AuthType: dara.String("AK"),
11211 Style: dara.String("RPC"),
11212 ReqBodyType: dara.String("formData"),
11213 BodyType: dara.String("json"),
11214 }
11215 _result = &UpdateCloudGtmAddressPoolRemarkResponse{}
11216 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11217 if _err != nil {
11218 return _result, _err
11219 }
11220 _err = dara.Convert(_body, &_result)
11221 return _result, _err
11222 }
11223
11224 // Summary:
11225 //
11226 // Modifies the remarks of an address.
11227 //
11228 // @param request - UpdateCloudGtmAddressRemarkRequest
11229 //
11230 // @param runtime - runtime options for this request RuntimeOptions
11231 //
11232 // @return UpdateCloudGtmAddressRemarkResponse
11233 func UpdateCloudGtmAddressRemarkWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmAddressRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmAddressRemarkResponse, _err error) {
11234 if dara.BoolValue(client.EnableValidate) == true {
11235 _err = request.Validate()
11236 if _err != nil {
11237 return _result, _err
11238 }
11239 }
11240 query := map[string]interface{}{}
11241 if !dara.IsNil(request.AcceptLanguage) {
11242 query["AcceptLanguage"] = request.AcceptLanguage
11243 }
11244
11245 if !dara.IsNil(request.AddressId) {
11246 query["AddressId"] = request.AddressId
11247 }
11248
11249 if !dara.IsNil(request.ClientToken) {
11250 query["ClientToken"] = request.ClientToken
11251 }
11252
11253 if !dara.IsNil(request.Remark) {
11254 query["Remark"] = request.Remark
11255 }
11256
11257 req := &openapiutil.OpenApiRequest{
11258 Query: openapiutil.Query(query),
11259 }
11260 params := &openapiutil.Params{
11261 Action: dara.String("UpdateCloudGtmAddressRemark"),
11262 Version: dara.String("2015-01-09"),
11263 Protocol: dara.String("HTTPS"),
11264 Pathname: dara.String("/"),
11265 Method: dara.String("POST"),
11266 AuthType: dara.String("AK"),
11267 Style: dara.String("RPC"),
11268 ReqBodyType: dara.String("formData"),
11269 BodyType: dara.String("json"),
11270 }
11271 _result = &UpdateCloudGtmAddressRemarkResponse{}
11272 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11273 if _err != nil {
11274 return _result, _err
11275 }
11276 _err = dara.Convert(_body, &_result)
11277 return _result, _err
11278 }
11279
11280 // @param tmpReq - UpdateCloudGtmGlobalAlertRequest
11281 //
11282 // @param runtime - runtime options for this request RuntimeOptions
11283 //
11284 // @return UpdateCloudGtmGlobalAlertResponse
11285 func UpdateCloudGtmGlobalAlertWithContext(ctx context.Context, client *Client, tmpReq *UpdateCloudGtmGlobalAlertRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmGlobalAlertResponse, _err error) {
11286 if dara.BoolValue(client.EnableValidate) == true {
11287 _err = tmpReq.Validate()
11288 if _err != nil {
11289 return _result, _err
11290 }
11291 }
11292 request := &UpdateCloudGtmGlobalAlertShrinkRequest{}
11293 openapiutil.Convert(tmpReq, request)
11294 if !dara.IsNil(tmpReq.AlertConfig) {
11295 request.AlertConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertConfig, dara.String("AlertConfig"), dara.String("json"))
11296 }
11297
11298 if !dara.IsNil(tmpReq.AlertGroup) {
11299 request.AlertGroupShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertGroup, dara.String("AlertGroup"), dara.String("json"))
11300 }
11301
11302 query := map[string]interface{}{}
11303 if !dara.IsNil(request.AcceptLanguage) {
11304 query["AcceptLanguage"] = request.AcceptLanguage
11305 }
11306
11307 if !dara.IsNil(request.AlertConfigShrink) {
11308 query["AlertConfig"] = request.AlertConfigShrink
11309 }
11310
11311 if !dara.IsNil(request.AlertGroupShrink) {
11312 query["AlertGroup"] = request.AlertGroupShrink
11313 }
11314
11315 if !dara.IsNil(request.ClientToken) {
11316 query["ClientToken"] = request.ClientToken
11317 }
11318
11319 req := &openapiutil.OpenApiRequest{
11320 Query: openapiutil.Query(query),
11321 }
11322 params := &openapiutil.Params{
11323 Action: dara.String("UpdateCloudGtmGlobalAlert"),
11324 Version: dara.String("2015-01-09"),
11325 Protocol: dara.String("HTTPS"),
11326 Pathname: dara.String("/"),
11327 Method: dara.String("POST"),
11328 AuthType: dara.String("AK"),
11329 Style: dara.String("RPC"),
11330 ReqBodyType: dara.String("formData"),
11331 BodyType: dara.String("json"),
11332 }
11333 _result = &UpdateCloudGtmGlobalAlertResponse{}
11334 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11335 if _err != nil {
11336 return _result, _err
11337 }
11338 _err = dara.Convert(_body, &_result)
11339 return _result, _err
11340 }
11341
11342 // @param tmpReq - UpdateCloudGtmInstanceConfigAlertRequest
11343 //
11344 // @param runtime - runtime options for this request RuntimeOptions
11345 //
11346 // @return UpdateCloudGtmInstanceConfigAlertResponse
11347 func UpdateCloudGtmInstanceConfigAlertWithContext(ctx context.Context, client *Client, tmpReq *UpdateCloudGtmInstanceConfigAlertRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigAlertResponse, _err error) {
11348 if dara.BoolValue(client.EnableValidate) == true {
11349 _err = tmpReq.Validate()
11350 if _err != nil {
11351 return _result, _err
11352 }
11353 }
11354 request := &UpdateCloudGtmInstanceConfigAlertShrinkRequest{}
11355 openapiutil.Convert(tmpReq, request)
11356 if !dara.IsNil(tmpReq.AlertConfig) {
11357 request.AlertConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertConfig, dara.String("AlertConfig"), dara.String("json"))
11358 }
11359
11360 if !dara.IsNil(tmpReq.AlertGroup) {
11361 request.AlertGroupShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AlertGroup, dara.String("AlertGroup"), dara.String("json"))
11362 }
11363
11364 query := map[string]interface{}{}
11365 if !dara.IsNil(request.AcceptLanguage) {
11366 query["AcceptLanguage"] = request.AcceptLanguage
11367 }
11368
11369 if !dara.IsNil(request.AlertConfigShrink) {
11370 query["AlertConfig"] = request.AlertConfigShrink
11371 }
11372
11373 if !dara.IsNil(request.AlertGroupShrink) {
11374 query["AlertGroup"] = request.AlertGroupShrink
11375 }
11376
11377 if !dara.IsNil(request.AlertMode) {
11378 query["AlertMode"] = request.AlertMode
11379 }
11380
11381 if !dara.IsNil(request.ClientToken) {
11382 query["ClientToken"] = request.ClientToken
11383 }
11384
11385 if !dara.IsNil(request.ConfigId) {
11386 query["ConfigId"] = request.ConfigId
11387 }
11388
11389 if !dara.IsNil(request.InstanceId) {
11390 query["InstanceId"] = request.InstanceId
11391 }
11392
11393 req := &openapiutil.OpenApiRequest{
11394 Query: openapiutil.Query(query),
11395 }
11396 params := &openapiutil.Params{
11397 Action: dara.String("UpdateCloudGtmInstanceConfigAlert"),
11398 Version: dara.String("2015-01-09"),
11399 Protocol: dara.String("HTTPS"),
11400 Pathname: dara.String("/"),
11401 Method: dara.String("POST"),
11402 AuthType: dara.String("AK"),
11403 Style: dara.String("RPC"),
11404 ReqBodyType: dara.String("formData"),
11405 BodyType: dara.String("json"),
11406 }
11407 _result = &UpdateCloudGtmInstanceConfigAlertResponse{}
11408 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11409 if _err != nil {
11410 return _result, _err
11411 }
11412 _err = dara.Convert(_body, &_result)
11413 return _result, _err
11414 }
11415
11416 // Summary:
11417 //
11418 // Updates the global time-to-live (TTL) configuration of a GTM 3.0 instance.
11419 //
11420 // @param request - UpdateCloudGtmInstanceConfigBasicRequest
11421 //
11422 // @param runtime - runtime options for this request RuntimeOptions
11423 //
11424 // @return UpdateCloudGtmInstanceConfigBasicResponse
11425 func UpdateCloudGtmInstanceConfigBasicWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmInstanceConfigBasicRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigBasicResponse, _err error) {
11426 if dara.BoolValue(client.EnableValidate) == true {
11427 _err = request.Validate()
11428 if _err != nil {
11429 return _result, _err
11430 }
11431 }
11432 query := map[string]interface{}{}
11433 if !dara.IsNil(request.AcceptLanguage) {
11434 query["AcceptLanguage"] = request.AcceptLanguage
11435 }
11436
11437 if !dara.IsNil(request.ClientToken) {
11438 query["ClientToken"] = request.ClientToken
11439 }
11440
11441 if !dara.IsNil(request.ConfigId) {
11442 query["ConfigId"] = request.ConfigId
11443 }
11444
11445 if !dara.IsNil(request.InstanceId) {
11446 query["InstanceId"] = request.InstanceId
11447 }
11448
11449 if !dara.IsNil(request.ScheduleHostname) {
11450 query["ScheduleHostname"] = request.ScheduleHostname
11451 }
11452
11453 if !dara.IsNil(request.ScheduleZoneName) {
11454 query["ScheduleZoneName"] = request.ScheduleZoneName
11455 }
11456
11457 if !dara.IsNil(request.Ttl) {
11458 query["Ttl"] = request.Ttl
11459 }
11460
11461 req := &openapiutil.OpenApiRequest{
11462 Query: openapiutil.Query(query),
11463 }
11464 params := &openapiutil.Params{
11465 Action: dara.String("UpdateCloudGtmInstanceConfigBasic"),
11466 Version: dara.String("2015-01-09"),
11467 Protocol: dara.String("HTTPS"),
11468 Pathname: dara.String("/"),
11469 Method: dara.String("POST"),
11470 AuthType: dara.String("AK"),
11471 Style: dara.String("RPC"),
11472 ReqBodyType: dara.String("formData"),
11473 BodyType: dara.String("json"),
11474 }
11475 _result = &UpdateCloudGtmInstanceConfigBasicResponse{}
11476 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11477 if _err != nil {
11478 return _result, _err
11479 }
11480 _err = dara.Convert(_body, &_result)
11481 return _result, _err
11482 }
11483
11484 // Summary:
11485 //
11486 // Modifies the enabling status of an access domain name.
11487 //
11488 // Description:
11489 //
11490 // If an access domain name is **enabled* - and the health state is **normal**, the access domain name is deemed **available**.
11491 //
11492 // - If an access domain name is **disabled* - or the health state is **abnormal**, the access domain name is deemed **unavailable**.
11493 //
11494 // @param request - UpdateCloudGtmInstanceConfigEnableStatusRequest
11495 //
11496 // @param runtime - runtime options for this request RuntimeOptions
11497 //
11498 // @return UpdateCloudGtmInstanceConfigEnableStatusResponse
11499 func UpdateCloudGtmInstanceConfigEnableStatusWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmInstanceConfigEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigEnableStatusResponse, _err error) {
11500 if dara.BoolValue(client.EnableValidate) == true {
11501 _err = request.Validate()
11502 if _err != nil {
11503 return _result, _err
11504 }
11505 }
11506 query := map[string]interface{}{}
11507 if !dara.IsNil(request.AcceptLanguage) {
11508 query["AcceptLanguage"] = request.AcceptLanguage
11509 }
11510
11511 if !dara.IsNil(request.ClientToken) {
11512 query["ClientToken"] = request.ClientToken
11513 }
11514
11515 if !dara.IsNil(request.ConfigId) {
11516 query["ConfigId"] = request.ConfigId
11517 }
11518
11519 if !dara.IsNil(request.EnableStatus) {
11520 query["EnableStatus"] = request.EnableStatus
11521 }
11522
11523 if !dara.IsNil(request.InstanceId) {
11524 query["InstanceId"] = request.InstanceId
11525 }
11526
11527 req := &openapiutil.OpenApiRequest{
11528 Query: openapiutil.Query(query),
11529 }
11530 params := &openapiutil.Params{
11531 Action: dara.String("UpdateCloudGtmInstanceConfigEnableStatus"),
11532 Version: dara.String("2015-01-09"),
11533 Protocol: dara.String("HTTPS"),
11534 Pathname: dara.String("/"),
11535 Method: dara.String("POST"),
11536 AuthType: dara.String("AK"),
11537 Style: dara.String("RPC"),
11538 ReqBodyType: dara.String("formData"),
11539 BodyType: dara.String("json"),
11540 }
11541 _result = &UpdateCloudGtmInstanceConfigEnableStatusResponse{}
11542 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11543 if _err != nil {
11544 return _result, _err
11545 }
11546 _err = dara.Convert(_body, &_result)
11547 return _result, _err
11548 }
11549
11550 // Summary:
11551 //
11552 // Modifies the load balancing policy of a Global Traffic Manager (GTM) 3.0 instance.
11553 //
11554 // @param request - UpdateCloudGtmInstanceConfigLbStrategyRequest
11555 //
11556 // @param runtime - runtime options for this request RuntimeOptions
11557 //
11558 // @return UpdateCloudGtmInstanceConfigLbStrategyResponse
11559 func UpdateCloudGtmInstanceConfigLbStrategyWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmInstanceConfigLbStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigLbStrategyResponse, _err error) {
11560 if dara.BoolValue(client.EnableValidate) == true {
11561 _err = request.Validate()
11562 if _err != nil {
11563 return _result, _err
11564 }
11565 }
11566 query := map[string]interface{}{}
11567 if !dara.IsNil(request.AcceptLanguage) {
11568 query["AcceptLanguage"] = request.AcceptLanguage
11569 }
11570
11571 if !dara.IsNil(request.AddressPoolLbStrategy) {
11572 query["AddressPoolLbStrategy"] = request.AddressPoolLbStrategy
11573 }
11574
11575 if !dara.IsNil(request.ClientToken) {
11576 query["ClientToken"] = request.ClientToken
11577 }
11578
11579 if !dara.IsNil(request.ConfigId) {
11580 query["ConfigId"] = request.ConfigId
11581 }
11582
11583 if !dara.IsNil(request.InstanceId) {
11584 query["InstanceId"] = request.InstanceId
11585 }
11586
11587 if !dara.IsNil(request.SequenceLbStrategyMode) {
11588 query["SequenceLbStrategyMode"] = request.SequenceLbStrategyMode
11589 }
11590
11591 req := &openapiutil.OpenApiRequest{
11592 Query: openapiutil.Query(query),
11593 }
11594 params := &openapiutil.Params{
11595 Action: dara.String("UpdateCloudGtmInstanceConfigLbStrategy"),
11596 Version: dara.String("2015-01-09"),
11597 Protocol: dara.String("HTTPS"),
11598 Pathname: dara.String("/"),
11599 Method: dara.String("POST"),
11600 AuthType: dara.String("AK"),
11601 Style: dara.String("RPC"),
11602 ReqBodyType: dara.String("formData"),
11603 BodyType: dara.String("json"),
11604 }
11605 _result = &UpdateCloudGtmInstanceConfigLbStrategyResponse{}
11606 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11607 if _err != nil {
11608 return _result, _err
11609 }
11610 _err = dara.Convert(_body, &_result)
11611 return _result, _err
11612 }
11613
11614 // Summary:
11615 //
11616 // Modifies the description of a Global Traffic Manager (GTM) 3.0 instance.
11617 //
11618 // @param request - UpdateCloudGtmInstanceConfigRemarkRequest
11619 //
11620 // @param runtime - runtime options for this request RuntimeOptions
11621 //
11622 // @return UpdateCloudGtmInstanceConfigRemarkResponse
11623 func UpdateCloudGtmInstanceConfigRemarkWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmInstanceConfigRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceConfigRemarkResponse, _err error) {
11624 if dara.BoolValue(client.EnableValidate) == true {
11625 _err = request.Validate()
11626 if _err != nil {
11627 return _result, _err
11628 }
11629 }
11630 query := map[string]interface{}{}
11631 if !dara.IsNil(request.AcceptLanguage) {
11632 query["AcceptLanguage"] = request.AcceptLanguage
11633 }
11634
11635 if !dara.IsNil(request.ClientToken) {
11636 query["ClientToken"] = request.ClientToken
11637 }
11638
11639 if !dara.IsNil(request.ConfigId) {
11640 query["ConfigId"] = request.ConfigId
11641 }
11642
11643 if !dara.IsNil(request.InstanceId) {
11644 query["InstanceId"] = request.InstanceId
11645 }
11646
11647 if !dara.IsNil(request.Remark) {
11648 query["Remark"] = request.Remark
11649 }
11650
11651 req := &openapiutil.OpenApiRequest{
11652 Query: openapiutil.Query(query),
11653 }
11654 params := &openapiutil.Params{
11655 Action: dara.String("UpdateCloudGtmInstanceConfigRemark"),
11656 Version: dara.String("2015-01-09"),
11657 Protocol: dara.String("HTTPS"),
11658 Pathname: dara.String("/"),
11659 Method: dara.String("POST"),
11660 AuthType: dara.String("AK"),
11661 Style: dara.String("RPC"),
11662 ReqBodyType: dara.String("formData"),
11663 BodyType: dara.String("json"),
11664 }
11665 _result = &UpdateCloudGtmInstanceConfigRemarkResponse{}
11666 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11667 if _err != nil {
11668 return _result, _err
11669 }
11670 _err = dara.Convert(_body, &_result)
11671 return _result, _err
11672 }
11673
11674 // @param request - UpdateCloudGtmInstanceNameRequest
11675 //
11676 // @param runtime - runtime options for this request RuntimeOptions
11677 //
11678 // @return UpdateCloudGtmInstanceNameResponse
11679 func UpdateCloudGtmInstanceNameWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmInstanceNameRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmInstanceNameResponse, _err error) {
11680 if dara.BoolValue(client.EnableValidate) == true {
11681 _err = request.Validate()
11682 if _err != nil {
11683 return _result, _err
11684 }
11685 }
11686 query := map[string]interface{}{}
11687 if !dara.IsNil(request.AcceptLanguage) {
11688 query["AcceptLanguage"] = request.AcceptLanguage
11689 }
11690
11691 if !dara.IsNil(request.ClientToken) {
11692 query["ClientToken"] = request.ClientToken
11693 }
11694
11695 if !dara.IsNil(request.InstanceId) {
11696 query["InstanceId"] = request.InstanceId
11697 }
11698
11699 if !dara.IsNil(request.InstanceName) {
11700 query["InstanceName"] = request.InstanceName
11701 }
11702
11703 req := &openapiutil.OpenApiRequest{
11704 Query: openapiutil.Query(query),
11705 }
11706 params := &openapiutil.Params{
11707 Action: dara.String("UpdateCloudGtmInstanceName"),
11708 Version: dara.String("2015-01-09"),
11709 Protocol: dara.String("HTTPS"),
11710 Pathname: dara.String("/"),
11711 Method: dara.String("POST"),
11712 AuthType: dara.String("AK"),
11713 Style: dara.String("RPC"),
11714 ReqBodyType: dara.String("formData"),
11715 BodyType: dara.String("json"),
11716 }
11717 _result = &UpdateCloudGtmInstanceNameResponse{}
11718 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11719 if _err != nil {
11720 return _result, _err
11721 }
11722 _err = dara.Convert(_body, &_result)
11723 return _result, _err
11724 }
11725
11726 // Summary:
11727 //
11728 // Modifies the information about a health check template.
11729 //
11730 // @param tmpReq - UpdateCloudGtmMonitorTemplateRequest
11731 //
11732 // @param runtime - runtime options for this request RuntimeOptions
11733 //
11734 // @return UpdateCloudGtmMonitorTemplateResponse
11735 func UpdateCloudGtmMonitorTemplateWithContext(ctx context.Context, client *Client, tmpReq *UpdateCloudGtmMonitorTemplateRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmMonitorTemplateResponse, _err error) {
11736 if dara.BoolValue(client.EnableValidate) == true {
11737 _err = tmpReq.Validate()
11738 if _err != nil {
11739 return _result, _err
11740 }
11741 }
11742 request := &UpdateCloudGtmMonitorTemplateShrinkRequest{}
11743 openapiutil.Convert(tmpReq, request)
11744 if !dara.IsNil(tmpReq.IspCityNodes) {
11745 request.IspCityNodesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.IspCityNodes, dara.String("IspCityNodes"), dara.String("json"))
11746 }
11747
11748 query := map[string]interface{}{}
11749 if !dara.IsNil(request.AcceptLanguage) {
11750 query["AcceptLanguage"] = request.AcceptLanguage
11751 }
11752
11753 if !dara.IsNil(request.ClientToken) {
11754 query["ClientToken"] = request.ClientToken
11755 }
11756
11757 if !dara.IsNil(request.EvaluationCount) {
11758 query["EvaluationCount"] = request.EvaluationCount
11759 }
11760
11761 if !dara.IsNil(request.ExtendInfo) {
11762 query["ExtendInfo"] = request.ExtendInfo
11763 }
11764
11765 if !dara.IsNil(request.FailureRate) {
11766 query["FailureRate"] = request.FailureRate
11767 }
11768
11769 if !dara.IsNil(request.Interval) {
11770 query["Interval"] = request.Interval
11771 }
11772
11773 if !dara.IsNil(request.IspCityNodesShrink) {
11774 query["IspCityNodes"] = request.IspCityNodesShrink
11775 }
11776
11777 if !dara.IsNil(request.Name) {
11778 query["Name"] = request.Name
11779 }
11780
11781 if !dara.IsNil(request.TemplateId) {
11782 query["TemplateId"] = request.TemplateId
11783 }
11784
11785 if !dara.IsNil(request.Timeout) {
11786 query["Timeout"] = request.Timeout
11787 }
11788
11789 req := &openapiutil.OpenApiRequest{
11790 Query: openapiutil.Query(query),
11791 }
11792 params := &openapiutil.Params{
11793 Action: dara.String("UpdateCloudGtmMonitorTemplate"),
11794 Version: dara.String("2015-01-09"),
11795 Protocol: dara.String("HTTPS"),
11796 Pathname: dara.String("/"),
11797 Method: dara.String("POST"),
11798 AuthType: dara.String("AK"),
11799 Style: dara.String("RPC"),
11800 ReqBodyType: dara.String("formData"),
11801 BodyType: dara.String("json"),
11802 }
11803 _result = &UpdateCloudGtmMonitorTemplateResponse{}
11804 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11805 if _err != nil {
11806 return _result, _err
11807 }
11808 _err = dara.Convert(_body, &_result)
11809 return _result, _err
11810 }
11811
11812 // @param request - UpdateCloudGtmMonitorTemplateRemarkRequest
11813 //
11814 // @param runtime - runtime options for this request RuntimeOptions
11815 //
11816 // @return UpdateCloudGtmMonitorTemplateRemarkResponse
11817 func UpdateCloudGtmMonitorTemplateRemarkWithContext(ctx context.Context, client *Client, request *UpdateCloudGtmMonitorTemplateRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateCloudGtmMonitorTemplateRemarkResponse, _err error) {
11818 if dara.BoolValue(client.EnableValidate) == true {
11819 _err = request.Validate()
11820 if _err != nil {
11821 return _result, _err
11822 }
11823 }
11824 query := map[string]interface{}{}
11825 if !dara.IsNil(request.AcceptLanguage) {
11826 query["AcceptLanguage"] = request.AcceptLanguage
11827 }
11828
11829 if !dara.IsNil(request.ClientToken) {
11830 query["ClientToken"] = request.ClientToken
11831 }
11832
11833 if !dara.IsNil(request.Remark) {
11834 query["Remark"] = request.Remark
11835 }
11836
11837 if !dara.IsNil(request.TemplateId) {
11838 query["TemplateId"] = request.TemplateId
11839 }
11840
11841 req := &openapiutil.OpenApiRequest{
11842 Query: openapiutil.Query(query),
11843 }
11844 params := &openapiutil.Params{
11845 Action: dara.String("UpdateCloudGtmMonitorTemplateRemark"),
11846 Version: dara.String("2015-01-09"),
11847 Protocol: dara.String("HTTPS"),
11848 Pathname: dara.String("/"),
11849 Method: dara.String("POST"),
11850 AuthType: dara.String("AK"),
11851 Style: dara.String("RPC"),
11852 ReqBodyType: dara.String("formData"),
11853 BodyType: dara.String("json"),
11854 }
11855 _result = &UpdateCloudGtmMonitorTemplateRemarkResponse{}
11856 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11857 if _err != nil {
11858 return _result, _err
11859 }
11860 _err = dara.Convert(_body, &_result)
11861 return _result, _err
11862 }
11863
11864 // Summary:
11865 //
11866 // Modifies a custom line with its unique ID.
11867 //
11868 // Description:
11869 //
11870 // In each CIDR block, the end IP address must be greater than or equal to the start IP address.\\
11871 //
11872 // The CIDR blocks that are specified for all custom lines of a domain name cannot be overlapped.
11873 //
11874 // @param request - UpdateCustomLineRequest
11875 //
11876 // @param runtime - runtime options for this request RuntimeOptions
11877 //
11878 // @return UpdateCustomLineResponse
11879 func UpdateCustomLineWithContext(ctx context.Context, client *Client, request *UpdateCustomLineRequest, runtime *dara.RuntimeOptions) (_result *UpdateCustomLineResponse, _err error) {
11880 if dara.BoolValue(client.EnableValidate) == true {
11881 _err = request.Validate()
11882 if _err != nil {
11883 return _result, _err
11884 }
11885 }
11886 query := map[string]interface{}{}
11887 if !dara.IsNil(request.IpSegment) {
11888 query["IpSegment"] = request.IpSegment
11889 }
11890
11891 if !dara.IsNil(request.Lang) {
11892 query["Lang"] = request.Lang
11893 }
11894
11895 if !dara.IsNil(request.LineId) {
11896 query["LineId"] = request.LineId
11897 }
11898
11899 if !dara.IsNil(request.LineName) {
11900 query["LineName"] = request.LineName
11901 }
11902
11903 req := &openapiutil.OpenApiRequest{
11904 Query: openapiutil.Query(query),
11905 }
11906 params := &openapiutil.Params{
11907 Action: dara.String("UpdateCustomLine"),
11908 Version: dara.String("2015-01-09"),
11909 Protocol: dara.String("HTTPS"),
11910 Pathname: dara.String("/"),
11911 Method: dara.String("POST"),
11912 AuthType: dara.String("AK"),
11913 Style: dara.String("RPC"),
11914 ReqBodyType: dara.String("formData"),
11915 BodyType: dara.String("json"),
11916 }
11917 _result = &UpdateCustomLineResponse{}
11918 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11919 if _err != nil {
11920 return _result, _err
11921 }
11922 _err = dara.Convert(_body, &_result)
11923 return _result, _err
11924 }
11925
11926 // Summary:
11927 //
11928 // Modifies the weight of a Domain Name System (DNS) record based on the specified parameters.
11929 //
11930 // @param request - UpdateDNSSLBWeightRequest
11931 //
11932 // @param runtime - runtime options for this request RuntimeOptions
11933 //
11934 // @return UpdateDNSSLBWeightResponse
11935 func UpdateDNSSLBWeightWithContext(ctx context.Context, client *Client, request *UpdateDNSSLBWeightRequest, runtime *dara.RuntimeOptions) (_result *UpdateDNSSLBWeightResponse, _err error) {
11936 if dara.BoolValue(client.EnableValidate) == true {
11937 _err = request.Validate()
11938 if _err != nil {
11939 return _result, _err
11940 }
11941 }
11942 query := map[string]interface{}{}
11943 if !dara.IsNil(request.Lang) {
11944 query["Lang"] = request.Lang
11945 }
11946
11947 if !dara.IsNil(request.RecordId) {
11948 query["RecordId"] = request.RecordId
11949 }
11950
11951 if !dara.IsNil(request.UserClientIp) {
11952 query["UserClientIp"] = request.UserClientIp
11953 }
11954
11955 if !dara.IsNil(request.Weight) {
11956 query["Weight"] = request.Weight
11957 }
11958
11959 req := &openapiutil.OpenApiRequest{
11960 Query: openapiutil.Query(query),
11961 }
11962 params := &openapiutil.Params{
11963 Action: dara.String("UpdateDNSSLBWeight"),
11964 Version: dara.String("2015-01-09"),
11965 Protocol: dara.String("HTTPS"),
11966 Pathname: dara.String("/"),
11967 Method: dara.String("POST"),
11968 AuthType: dara.String("AK"),
11969 Style: dara.String("RPC"),
11970 ReqBodyType: dara.String("formData"),
11971 BodyType: dara.String("json"),
11972 }
11973 _result = &UpdateDNSSLBWeightResponse{}
11974 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11975 if _err != nil {
11976 return _result, _err
11977 }
11978 _err = dara.Convert(_body, &_result)
11979 return _result, _err
11980 }
11981
11982 // Summary:
11983 //
11984 // Updates the cache-accelerated domain name based on the specified parameters.
11985 //
11986 // @param request - UpdateDnsCacheDomainRequest
11987 //
11988 // @param runtime - runtime options for this request RuntimeOptions
11989 //
11990 // @return UpdateDnsCacheDomainResponse
11991 func UpdateDnsCacheDomainWithContext(ctx context.Context, client *Client, request *UpdateDnsCacheDomainRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsCacheDomainResponse, _err error) {
11992 if dara.BoolValue(client.EnableValidate) == true {
11993 _err = request.Validate()
11994 if _err != nil {
11995 return _result, _err
11996 }
11997 }
11998 query := map[string]interface{}{}
11999 if !dara.IsNil(request.CacheTtlMax) {
12000 query["CacheTtlMax"] = request.CacheTtlMax
12001 }
12002
12003 if !dara.IsNil(request.CacheTtlMin) {
12004 query["CacheTtlMin"] = request.CacheTtlMin
12005 }
12006
12007 if !dara.IsNil(request.DomainName) {
12008 query["DomainName"] = request.DomainName
12009 }
12010
12011 if !dara.IsNil(request.InstanceId) {
12012 query["InstanceId"] = request.InstanceId
12013 }
12014
12015 if !dara.IsNil(request.Lang) {
12016 query["Lang"] = request.Lang
12017 }
12018
12019 if !dara.IsNil(request.SourceDnsServer) {
12020 query["SourceDnsServer"] = request.SourceDnsServer
12021 }
12022
12023 if !dara.IsNil(request.SourceEdns) {
12024 query["SourceEdns"] = request.SourceEdns
12025 }
12026
12027 if !dara.IsNil(request.SourceProtocol) {
12028 query["SourceProtocol"] = request.SourceProtocol
12029 }
12030
12031 req := &openapiutil.OpenApiRequest{
12032 Query: openapiutil.Query(query),
12033 }
12034 params := &openapiutil.Params{
12035 Action: dara.String("UpdateDnsCacheDomain"),
12036 Version: dara.String("2015-01-09"),
12037 Protocol: dara.String("HTTPS"),
12038 Pathname: dara.String("/"),
12039 Method: dara.String("POST"),
12040 AuthType: dara.String("AK"),
12041 Style: dara.String("RPC"),
12042 ReqBodyType: dara.String("formData"),
12043 BodyType: dara.String("json"),
12044 }
12045 _result = &UpdateDnsCacheDomainResponse{}
12046 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12047 if _err != nil {
12048 return _result, _err
12049 }
12050 _err = dara.Convert(_body, &_result)
12051 return _result, _err
12052 }
12053
12054 // Summary:
12055 //
12056 // Updates the remarks for the cache-accelerated domain name of the destination domain name.
12057 //
12058 // @param request - UpdateDnsCacheDomainRemarkRequest
12059 //
12060 // @param runtime - runtime options for this request RuntimeOptions
12061 //
12062 // @return UpdateDnsCacheDomainRemarkResponse
12063 func UpdateDnsCacheDomainRemarkWithContext(ctx context.Context, client *Client, request *UpdateDnsCacheDomainRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsCacheDomainRemarkResponse, _err error) {
12064 if dara.BoolValue(client.EnableValidate) == true {
12065 _err = request.Validate()
12066 if _err != nil {
12067 return _result, _err
12068 }
12069 }
12070 query := map[string]interface{}{}
12071 if !dara.IsNil(request.DomainName) {
12072 query["DomainName"] = request.DomainName
12073 }
12074
12075 if !dara.IsNil(request.Lang) {
12076 query["Lang"] = request.Lang
12077 }
12078
12079 if !dara.IsNil(request.Remark) {
12080 query["Remark"] = request.Remark
12081 }
12082
12083 req := &openapiutil.OpenApiRequest{
12084 Query: openapiutil.Query(query),
12085 }
12086 params := &openapiutil.Params{
12087 Action: dara.String("UpdateDnsCacheDomainRemark"),
12088 Version: dara.String("2015-01-09"),
12089 Protocol: dara.String("HTTPS"),
12090 Pathname: dara.String("/"),
12091 Method: dara.String("POST"),
12092 AuthType: dara.String("AK"),
12093 Style: dara.String("RPC"),
12094 ReqBodyType: dara.String("formData"),
12095 BodyType: dara.String("json"),
12096 }
12097 _result = &UpdateDnsCacheDomainRemarkResponse{}
12098 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12099 if _err != nil {
12100 return _result, _err
12101 }
12102 _err = dara.Convert(_body, &_result)
12103 return _result, _err
12104 }
12105
12106 // Summary:
12107 //
12108 // Modifies an access policy.
12109 //
12110 // @param request - UpdateDnsGtmAccessStrategyRequest
12111 //
12112 // @param runtime - runtime options for this request RuntimeOptions
12113 //
12114 // @return UpdateDnsGtmAccessStrategyResponse
12115 func UpdateDnsGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *UpdateDnsGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmAccessStrategyResponse, _err error) {
12116 if dara.BoolValue(client.EnableValidate) == true {
12117 _err = request.Validate()
12118 if _err != nil {
12119 return _result, _err
12120 }
12121 }
12122 query := map[string]interface{}{}
12123 if !dara.IsNil(request.AccessMode) {
12124 query["AccessMode"] = request.AccessMode
12125 }
12126
12127 if !dara.IsNil(request.DefaultAddrPool) {
12128 query["DefaultAddrPool"] = request.DefaultAddrPool
12129 }
12130
12131 if !dara.IsNil(request.DefaultAddrPoolType) {
12132 query["DefaultAddrPoolType"] = request.DefaultAddrPoolType
12133 }
12134
12135 if !dara.IsNil(request.DefaultLatencyOptimization) {
12136 query["DefaultLatencyOptimization"] = request.DefaultLatencyOptimization
12137 }
12138
12139 if !dara.IsNil(request.DefaultLbaStrategy) {
12140 query["DefaultLbaStrategy"] = request.DefaultLbaStrategy
12141 }
12142
12143 if !dara.IsNil(request.DefaultMaxReturnAddrNum) {
12144 query["DefaultMaxReturnAddrNum"] = request.DefaultMaxReturnAddrNum
12145 }
12146
12147 if !dara.IsNil(request.DefaultMinAvailableAddrNum) {
12148 query["DefaultMinAvailableAddrNum"] = request.DefaultMinAvailableAddrNum
12149 }
12150
12151 if !dara.IsNil(request.FailoverAddrPool) {
12152 query["FailoverAddrPool"] = request.FailoverAddrPool
12153 }
12154
12155 if !dara.IsNil(request.FailoverAddrPoolType) {
12156 query["FailoverAddrPoolType"] = request.FailoverAddrPoolType
12157 }
12158
12159 if !dara.IsNil(request.FailoverLatencyOptimization) {
12160 query["FailoverLatencyOptimization"] = request.FailoverLatencyOptimization
12161 }
12162
12163 if !dara.IsNil(request.FailoverLbaStrategy) {
12164 query["FailoverLbaStrategy"] = request.FailoverLbaStrategy
12165 }
12166
12167 if !dara.IsNil(request.FailoverMaxReturnAddrNum) {
12168 query["FailoverMaxReturnAddrNum"] = request.FailoverMaxReturnAddrNum
12169 }
12170
12171 if !dara.IsNil(request.FailoverMinAvailableAddrNum) {
12172 query["FailoverMinAvailableAddrNum"] = request.FailoverMinAvailableAddrNum
12173 }
12174
12175 if !dara.IsNil(request.Lang) {
12176 query["Lang"] = request.Lang
12177 }
12178
12179 if !dara.IsNil(request.Lines) {
12180 query["Lines"] = request.Lines
12181 }
12182
12183 if !dara.IsNil(request.StrategyId) {
12184 query["StrategyId"] = request.StrategyId
12185 }
12186
12187 if !dara.IsNil(request.StrategyName) {
12188 query["StrategyName"] = request.StrategyName
12189 }
12190
12191 req := &openapiutil.OpenApiRequest{
12192 Query: openapiutil.Query(query),
12193 }
12194 params := &openapiutil.Params{
12195 Action: dara.String("UpdateDnsGtmAccessStrategy"),
12196 Version: dara.String("2015-01-09"),
12197 Protocol: dara.String("HTTPS"),
12198 Pathname: dara.String("/"),
12199 Method: dara.String("POST"),
12200 AuthType: dara.String("AK"),
12201 Style: dara.String("RPC"),
12202 ReqBodyType: dara.String("formData"),
12203 BodyType: dara.String("json"),
12204 }
12205 _result = &UpdateDnsGtmAccessStrategyResponse{}
12206 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12207 if _err != nil {
12208 return _result, _err
12209 }
12210 _err = dara.Convert(_body, &_result)
12211 return _result, _err
12212 }
12213
12214 // Summary:
12215 //
12216 // Modifies an address pool.
12217 //
12218 // @param request - UpdateDnsGtmAddressPoolRequest
12219 //
12220 // @param runtime - runtime options for this request RuntimeOptions
12221 //
12222 // @return UpdateDnsGtmAddressPoolResponse
12223 func UpdateDnsGtmAddressPoolWithContext(ctx context.Context, client *Client, request *UpdateDnsGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmAddressPoolResponse, _err error) {
12224 if dara.BoolValue(client.EnableValidate) == true {
12225 _err = request.Validate()
12226 if _err != nil {
12227 return _result, _err
12228 }
12229 }
12230 query := map[string]interface{}{}
12231 if !dara.IsNil(request.Addr) {
12232 query["Addr"] = request.Addr
12233 }
12234
12235 if !dara.IsNil(request.AddrPoolId) {
12236 query["AddrPoolId"] = request.AddrPoolId
12237 }
12238
12239 if !dara.IsNil(request.Lang) {
12240 query["Lang"] = request.Lang
12241 }
12242
12243 if !dara.IsNil(request.LbaStrategy) {
12244 query["LbaStrategy"] = request.LbaStrategy
12245 }
12246
12247 if !dara.IsNil(request.Name) {
12248 query["Name"] = request.Name
12249 }
12250
12251 req := &openapiutil.OpenApiRequest{
12252 Query: openapiutil.Query(query),
12253 }
12254 params := &openapiutil.Params{
12255 Action: dara.String("UpdateDnsGtmAddressPool"),
12256 Version: dara.String("2015-01-09"),
12257 Protocol: dara.String("HTTPS"),
12258 Pathname: dara.String("/"),
12259 Method: dara.String("POST"),
12260 AuthType: dara.String("AK"),
12261 Style: dara.String("RPC"),
12262 ReqBodyType: dara.String("formData"),
12263 BodyType: dara.String("json"),
12264 }
12265 _result = &UpdateDnsGtmAddressPoolResponse{}
12266 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12267 if _err != nil {
12268 return _result, _err
12269 }
12270 _err = dara.Convert(_body, &_result)
12271 return _result, _err
12272 }
12273
12274 // Summary:
12275 //
12276 // Modifies the configurations of a Global Traffic Manager (GTM) instance.
12277 //
12278 // @param request - UpdateDnsGtmInstanceGlobalConfigRequest
12279 //
12280 // @param runtime - runtime options for this request RuntimeOptions
12281 //
12282 // @return UpdateDnsGtmInstanceGlobalConfigResponse
12283 func UpdateDnsGtmInstanceGlobalConfigWithContext(ctx context.Context, client *Client, request *UpdateDnsGtmInstanceGlobalConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmInstanceGlobalConfigResponse, _err error) {
12284 if dara.BoolValue(client.EnableValidate) == true {
12285 _err = request.Validate()
12286 if _err != nil {
12287 return _result, _err
12288 }
12289 }
12290 query := map[string]interface{}{}
12291 if !dara.IsNil(request.AlertConfig) {
12292 query["AlertConfig"] = request.AlertConfig
12293 }
12294
12295 if !dara.IsNil(request.AlertGroup) {
12296 query["AlertGroup"] = request.AlertGroup
12297 }
12298
12299 if !dara.IsNil(request.CnameType) {
12300 query["CnameType"] = request.CnameType
12301 }
12302
12303 if !dara.IsNil(request.ForceUpdate) {
12304 query["ForceUpdate"] = request.ForceUpdate
12305 }
12306
12307 if !dara.IsNil(request.InstanceId) {
12308 query["InstanceId"] = request.InstanceId
12309 }
12310
12311 if !dara.IsNil(request.InstanceName) {
12312 query["InstanceName"] = request.InstanceName
12313 }
12314
12315 if !dara.IsNil(request.Lang) {
12316 query["Lang"] = request.Lang
12317 }
12318
12319 if !dara.IsNil(request.PublicCnameMode) {
12320 query["PublicCnameMode"] = request.PublicCnameMode
12321 }
12322
12323 if !dara.IsNil(request.PublicRr) {
12324 query["PublicRr"] = request.PublicRr
12325 }
12326
12327 if !dara.IsNil(request.PublicUserDomainName) {
12328 query["PublicUserDomainName"] = request.PublicUserDomainName
12329 }
12330
12331 if !dara.IsNil(request.PublicZoneName) {
12332 query["PublicZoneName"] = request.PublicZoneName
12333 }
12334
12335 if !dara.IsNil(request.Ttl) {
12336 query["Ttl"] = request.Ttl
12337 }
12338
12339 req := &openapiutil.OpenApiRequest{
12340 Query: openapiutil.Query(query),
12341 }
12342 params := &openapiutil.Params{
12343 Action: dara.String("UpdateDnsGtmInstanceGlobalConfig"),
12344 Version: dara.String("2015-01-09"),
12345 Protocol: dara.String("HTTPS"),
12346 Pathname: dara.String("/"),
12347 Method: dara.String("POST"),
12348 AuthType: dara.String("AK"),
12349 Style: dara.String("RPC"),
12350 ReqBodyType: dara.String("formData"),
12351 BodyType: dara.String("json"),
12352 }
12353 _result = &UpdateDnsGtmInstanceGlobalConfigResponse{}
12354 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12355 if _err != nil {
12356 return _result, _err
12357 }
12358 _err = dara.Convert(_body, &_result)
12359 return _result, _err
12360 }
12361
12362 // Summary:
12363 //
12364 // Modifies a health check task.
12365 //
12366 // @param request - UpdateDnsGtmMonitorRequest
12367 //
12368 // @param runtime - runtime options for this request RuntimeOptions
12369 //
12370 // @return UpdateDnsGtmMonitorResponse
12371 func UpdateDnsGtmMonitorWithContext(ctx context.Context, client *Client, request *UpdateDnsGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *UpdateDnsGtmMonitorResponse, _err error) {
12372 if dara.BoolValue(client.EnableValidate) == true {
12373 _err = request.Validate()
12374 if _err != nil {
12375 return _result, _err
12376 }
12377 }
12378 query := map[string]interface{}{}
12379 if !dara.IsNil(request.EvaluationCount) {
12380 query["EvaluationCount"] = request.EvaluationCount
12381 }
12382
12383 if !dara.IsNil(request.Interval) {
12384 query["Interval"] = request.Interval
12385 }
12386
12387 if !dara.IsNil(request.IspCityNode) {
12388 query["IspCityNode"] = request.IspCityNode
12389 }
12390
12391 if !dara.IsNil(request.Lang) {
12392 query["Lang"] = request.Lang
12393 }
12394
12395 if !dara.IsNil(request.MonitorConfigId) {
12396 query["MonitorConfigId"] = request.MonitorConfigId
12397 }
12398
12399 if !dara.IsNil(request.MonitorExtendInfo) {
12400 query["MonitorExtendInfo"] = request.MonitorExtendInfo
12401 }
12402
12403 if !dara.IsNil(request.ProtocolType) {
12404 query["ProtocolType"] = request.ProtocolType
12405 }
12406
12407 if !dara.IsNil(request.Timeout) {
12408 query["Timeout"] = request.Timeout
12409 }
12410
12411 req := &openapiutil.OpenApiRequest{
12412 Query: openapiutil.Query(query),
12413 }
12414 params := &openapiutil.Params{
12415 Action: dara.String("UpdateDnsGtmMonitor"),
12416 Version: dara.String("2015-01-09"),
12417 Protocol: dara.String("HTTPS"),
12418 Pathname: dara.String("/"),
12419 Method: dara.String("POST"),
12420 AuthType: dara.String("AK"),
12421 Style: dara.String("RPC"),
12422 ReqBodyType: dara.String("formData"),
12423 BodyType: dara.String("json"),
12424 }
12425 _result = &UpdateDnsGtmMonitorResponse{}
12426 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12427 if _err != nil {
12428 return _result, _err
12429 }
12430 _err = dara.Convert(_body, &_result)
12431 return _result, _err
12432 }
12433
12434 // Summary:
12435 //
12436 // Modifies the name of a domain name group based on the specified parameters.
12437 //
12438 // Description:
12439 //
12440 // Modifies the name of an existing domain name group.
12441 //
12442 // @param request - UpdateDomainGroupRequest
12443 //
12444 // @param runtime - runtime options for this request RuntimeOptions
12445 //
12446 // @return UpdateDomainGroupResponse
12447 func UpdateDomainGroupWithContext(ctx context.Context, client *Client, request *UpdateDomainGroupRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainGroupResponse, _err error) {
12448 if dara.BoolValue(client.EnableValidate) == true {
12449 _err = request.Validate()
12450 if _err != nil {
12451 return _result, _err
12452 }
12453 }
12454 query := map[string]interface{}{}
12455 if !dara.IsNil(request.GroupId) {
12456 query["GroupId"] = request.GroupId
12457 }
12458
12459 if !dara.IsNil(request.GroupName) {
12460 query["GroupName"] = request.GroupName
12461 }
12462
12463 if !dara.IsNil(request.Lang) {
12464 query["Lang"] = request.Lang
12465 }
12466
12467 req := &openapiutil.OpenApiRequest{
12468 Query: openapiutil.Query(query),
12469 }
12470 params := &openapiutil.Params{
12471 Action: dara.String("UpdateDomainGroup"),
12472 Version: dara.String("2015-01-09"),
12473 Protocol: dara.String("HTTPS"),
12474 Pathname: dara.String("/"),
12475 Method: dara.String("POST"),
12476 AuthType: dara.String("AK"),
12477 Style: dara.String("RPC"),
12478 ReqBodyType: dara.String("formData"),
12479 BodyType: dara.String("json"),
12480 }
12481 _result = &UpdateDomainGroupResponse{}
12482 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12483 if _err != nil {
12484 return _result, _err
12485 }
12486 _err = dara.Convert(_body, &_result)
12487 return _result, _err
12488 }
12489
12490 // Summary:
12491 //
12492 // Modifies a Domain Name System (DNS) record based on the specified parameters.
12493 //
12494 // @param request - UpdateDomainRecordRequest
12495 //
12496 // @param runtime - runtime options for this request RuntimeOptions
12497 //
12498 // @return UpdateDomainRecordResponse
12499 func UpdateDomainRecordWithContext(ctx context.Context, client *Client, request *UpdateDomainRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRecordResponse, _err error) {
12500 if dara.BoolValue(client.EnableValidate) == true {
12501 _err = request.Validate()
12502 if _err != nil {
12503 return _result, _err
12504 }
12505 }
12506 query := map[string]interface{}{}
12507 if !dara.IsNil(request.Lang) {
12508 query["Lang"] = request.Lang
12509 }
12510
12511 if !dara.IsNil(request.Line) {
12512 query["Line"] = request.Line
12513 }
12514
12515 if !dara.IsNil(request.Priority) {
12516 query["Priority"] = request.Priority
12517 }
12518
12519 if !dara.IsNil(request.RR) {
12520 query["RR"] = request.RR
12521 }
12522
12523 if !dara.IsNil(request.RecordId) {
12524 query["RecordId"] = request.RecordId
12525 }
12526
12527 if !dara.IsNil(request.TTL) {
12528 query["TTL"] = request.TTL
12529 }
12530
12531 if !dara.IsNil(request.Type) {
12532 query["Type"] = request.Type
12533 }
12534
12535 if !dara.IsNil(request.UserClientIp) {
12536 query["UserClientIp"] = request.UserClientIp
12537 }
12538
12539 if !dara.IsNil(request.Value) {
12540 query["Value"] = request.Value
12541 }
12542
12543 req := &openapiutil.OpenApiRequest{
12544 Query: openapiutil.Query(query),
12545 }
12546 params := &openapiutil.Params{
12547 Action: dara.String("UpdateDomainRecord"),
12548 Version: dara.String("2015-01-09"),
12549 Protocol: dara.String("HTTPS"),
12550 Pathname: dara.String("/"),
12551 Method: dara.String("POST"),
12552 AuthType: dara.String("AK"),
12553 Style: dara.String("RPC"),
12554 ReqBodyType: dara.String("formData"),
12555 BodyType: dara.String("json"),
12556 }
12557 _result = &UpdateDomainRecordResponse{}
12558 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12559 if _err != nil {
12560 return _result, _err
12561 }
12562 _err = dara.Convert(_body, &_result)
12563 return _result, _err
12564 }
12565
12566 // Summary:
12567 //
12568 // Modifies the description of a Domain Name System (DNS) record based on the specified parameters.
12569 //
12570 // @param request - UpdateDomainRecordRemarkRequest
12571 //
12572 // @param runtime - runtime options for this request RuntimeOptions
12573 //
12574 // @return UpdateDomainRecordRemarkResponse
12575 func UpdateDomainRecordRemarkWithContext(ctx context.Context, client *Client, request *UpdateDomainRecordRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRecordRemarkResponse, _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.Lang) {
12584 query["Lang"] = request.Lang
12585 }
12586
12587 if !dara.IsNil(request.RecordId) {
12588 query["RecordId"] = request.RecordId
12589 }
12590
12591 if !dara.IsNil(request.Remark) {
12592 query["Remark"] = request.Remark
12593 }
12594
12595 if !dara.IsNil(request.UserClientIp) {
12596 query["UserClientIp"] = request.UserClientIp
12597 }
12598
12599 req := &openapiutil.OpenApiRequest{
12600 Query: openapiutil.Query(query),
12601 }
12602 params := &openapiutil.Params{
12603 Action: dara.String("UpdateDomainRecordRemark"),
12604 Version: dara.String("2015-01-09"),
12605 Protocol: dara.String("HTTPS"),
12606 Pathname: dara.String("/"),
12607 Method: dara.String("POST"),
12608 AuthType: dara.String("AK"),
12609 Style: dara.String("RPC"),
12610 ReqBodyType: dara.String("formData"),
12611 BodyType: dara.String("json"),
12612 }
12613 _result = &UpdateDomainRecordRemarkResponse{}
12614 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12615 if _err != nil {
12616 return _result, _err
12617 }
12618 _err = dara.Convert(_body, &_result)
12619 return _result, _err
12620 }
12621
12622 // Summary:
12623 //
12624 // Modifies the description of a domain name based on the specified parameters.
12625 //
12626 // @param request - UpdateDomainRemarkRequest
12627 //
12628 // @param runtime - runtime options for this request RuntimeOptions
12629 //
12630 // @return UpdateDomainRemarkResponse
12631 func UpdateDomainRemarkWithContext(ctx context.Context, client *Client, request *UpdateDomainRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateDomainRemarkResponse, _err error) {
12632 if dara.BoolValue(client.EnableValidate) == true {
12633 _err = request.Validate()
12634 if _err != nil {
12635 return _result, _err
12636 }
12637 }
12638 query := map[string]interface{}{}
12639 if !dara.IsNil(request.DomainName) {
12640 query["DomainName"] = request.DomainName
12641 }
12642
12643 if !dara.IsNil(request.Lang) {
12644 query["Lang"] = request.Lang
12645 }
12646
12647 if !dara.IsNil(request.Remark) {
12648 query["Remark"] = request.Remark
12649 }
12650
12651 req := &openapiutil.OpenApiRequest{
12652 Query: openapiutil.Query(query),
12653 }
12654 params := &openapiutil.Params{
12655 Action: dara.String("UpdateDomainRemark"),
12656 Version: dara.String("2015-01-09"),
12657 Protocol: dara.String("HTTPS"),
12658 Pathname: dara.String("/"),
12659 Method: dara.String("POST"),
12660 AuthType: dara.String("AK"),
12661 Style: dara.String("RPC"),
12662 ReqBodyType: dara.String("formData"),
12663 BodyType: dara.String("json"),
12664 }
12665 _result = &UpdateDomainRemarkResponse{}
12666 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12667 if _err != nil {
12668 return _result, _err
12669 }
12670 _err = dara.Convert(_body, &_result)
12671 return _result, _err
12672 }
12673
12674 // @param request - UpdateGtmAccessStrategyRequest
12675 //
12676 // @param runtime - runtime options for this request RuntimeOptions
12677 //
12678 // @return UpdateGtmAccessStrategyResponse
12679 func UpdateGtmAccessStrategyWithContext(ctx context.Context, client *Client, request *UpdateGtmAccessStrategyRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmAccessStrategyResponse, _err error) {
12680 if dara.BoolValue(client.EnableValidate) == true {
12681 _err = request.Validate()
12682 if _err != nil {
12683 return _result, _err
12684 }
12685 }
12686 query := map[string]interface{}{}
12687 if !dara.IsNil(request.AccessLines) {
12688 query["AccessLines"] = request.AccessLines
12689 }
12690
12691 if !dara.IsNil(request.DefaultAddrPoolId) {
12692 query["DefaultAddrPoolId"] = request.DefaultAddrPoolId
12693 }
12694
12695 if !dara.IsNil(request.FailoverAddrPoolId) {
12696 query["FailoverAddrPoolId"] = request.FailoverAddrPoolId
12697 }
12698
12699 if !dara.IsNil(request.Lang) {
12700 query["Lang"] = request.Lang
12701 }
12702
12703 if !dara.IsNil(request.StrategyId) {
12704 query["StrategyId"] = request.StrategyId
12705 }
12706
12707 if !dara.IsNil(request.StrategyName) {
12708 query["StrategyName"] = request.StrategyName
12709 }
12710
12711 req := &openapiutil.OpenApiRequest{
12712 Query: openapiutil.Query(query),
12713 }
12714 params := &openapiutil.Params{
12715 Action: dara.String("UpdateGtmAccessStrategy"),
12716 Version: dara.String("2015-01-09"),
12717 Protocol: dara.String("HTTPS"),
12718 Pathname: dara.String("/"),
12719 Method: dara.String("POST"),
12720 AuthType: dara.String("AK"),
12721 Style: dara.String("RPC"),
12722 ReqBodyType: dara.String("formData"),
12723 BodyType: dara.String("json"),
12724 }
12725 _result = &UpdateGtmAccessStrategyResponse{}
12726 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12727 if _err != nil {
12728 return _result, _err
12729 }
12730 _err = dara.Convert(_body, &_result)
12731 return _result, _err
12732 }
12733
12734 // @param request - UpdateGtmAddressPoolRequest
12735 //
12736 // @param runtime - runtime options for this request RuntimeOptions
12737 //
12738 // @return UpdateGtmAddressPoolResponse
12739 func UpdateGtmAddressPoolWithContext(ctx context.Context, client *Client, request *UpdateGtmAddressPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmAddressPoolResponse, _err error) {
12740 if dara.BoolValue(client.EnableValidate) == true {
12741 _err = request.Validate()
12742 if _err != nil {
12743 return _result, _err
12744 }
12745 }
12746 query := map[string]interface{}{}
12747 if !dara.IsNil(request.Addr) {
12748 query["Addr"] = request.Addr
12749 }
12750
12751 if !dara.IsNil(request.AddrPoolId) {
12752 query["AddrPoolId"] = request.AddrPoolId
12753 }
12754
12755 if !dara.IsNil(request.Lang) {
12756 query["Lang"] = request.Lang
12757 }
12758
12759 if !dara.IsNil(request.MinAvailableAddrNum) {
12760 query["MinAvailableAddrNum"] = request.MinAvailableAddrNum
12761 }
12762
12763 if !dara.IsNil(request.Name) {
12764 query["Name"] = request.Name
12765 }
12766
12767 if !dara.IsNil(request.Type) {
12768 query["Type"] = request.Type
12769 }
12770
12771 req := &openapiutil.OpenApiRequest{
12772 Query: openapiutil.Query(query),
12773 }
12774 params := &openapiutil.Params{
12775 Action: dara.String("UpdateGtmAddressPool"),
12776 Version: dara.String("2015-01-09"),
12777 Protocol: dara.String("HTTPS"),
12778 Pathname: dara.String("/"),
12779 Method: dara.String("POST"),
12780 AuthType: dara.String("AK"),
12781 Style: dara.String("RPC"),
12782 ReqBodyType: dara.String("formData"),
12783 BodyType: dara.String("json"),
12784 }
12785 _result = &UpdateGtmAddressPoolResponse{}
12786 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12787 if _err != nil {
12788 return _result, _err
12789 }
12790 _err = dara.Convert(_body, &_result)
12791 return _result, _err
12792 }
12793
12794 // Summary:
12795 //
12796 // Modifies the configurations of a Global Traffic Manager (GTM) instance based on the specified parameters.
12797 //
12798 // @param request - UpdateGtmInstanceGlobalConfigRequest
12799 //
12800 // @param runtime - runtime options for this request RuntimeOptions
12801 //
12802 // @return UpdateGtmInstanceGlobalConfigResponse
12803 func UpdateGtmInstanceGlobalConfigWithContext(ctx context.Context, client *Client, request *UpdateGtmInstanceGlobalConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmInstanceGlobalConfigResponse, _err error) {
12804 if dara.BoolValue(client.EnableValidate) == true {
12805 _err = request.Validate()
12806 if _err != nil {
12807 return _result, _err
12808 }
12809 }
12810 query := map[string]interface{}{}
12811 if !dara.IsNil(request.AlertGroup) {
12812 query["AlertGroup"] = request.AlertGroup
12813 }
12814
12815 if !dara.IsNil(request.CnameCustomDomainName) {
12816 query["CnameCustomDomainName"] = request.CnameCustomDomainName
12817 }
12818
12819 if !dara.IsNil(request.CnameMode) {
12820 query["CnameMode"] = request.CnameMode
12821 }
12822
12823 if !dara.IsNil(request.InstanceId) {
12824 query["InstanceId"] = request.InstanceId
12825 }
12826
12827 if !dara.IsNil(request.InstanceName) {
12828 query["InstanceName"] = request.InstanceName
12829 }
12830
12831 if !dara.IsNil(request.Lang) {
12832 query["Lang"] = request.Lang
12833 }
12834
12835 if !dara.IsNil(request.LbaStrategy) {
12836 query["LbaStrategy"] = request.LbaStrategy
12837 }
12838
12839 if !dara.IsNil(request.Ttl) {
12840 query["Ttl"] = request.Ttl
12841 }
12842
12843 if !dara.IsNil(request.UserDomainName) {
12844 query["UserDomainName"] = request.UserDomainName
12845 }
12846
12847 req := &openapiutil.OpenApiRequest{
12848 Query: openapiutil.Query(query),
12849 }
12850 params := &openapiutil.Params{
12851 Action: dara.String("UpdateGtmInstanceGlobalConfig"),
12852 Version: dara.String("2015-01-09"),
12853 Protocol: dara.String("HTTPS"),
12854 Pathname: dara.String("/"),
12855 Method: dara.String("POST"),
12856 AuthType: dara.String("AK"),
12857 Style: dara.String("RPC"),
12858 ReqBodyType: dara.String("formData"),
12859 BodyType: dara.String("json"),
12860 }
12861 _result = &UpdateGtmInstanceGlobalConfigResponse{}
12862 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12863 if _err != nil {
12864 return _result, _err
12865 }
12866 _err = dara.Convert(_body, &_result)
12867 return _result, _err
12868 }
12869
12870 // Summary:
12871 //
12872 // Modifies the health check configuration for an address pool of a Global Traffic Manager (GTM) instance.
12873 //
12874 // @param request - UpdateGtmMonitorRequest
12875 //
12876 // @param runtime - runtime options for this request RuntimeOptions
12877 //
12878 // @return UpdateGtmMonitorResponse
12879 func UpdateGtmMonitorWithContext(ctx context.Context, client *Client, request *UpdateGtmMonitorRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmMonitorResponse, _err error) {
12880 if dara.BoolValue(client.EnableValidate) == true {
12881 _err = request.Validate()
12882 if _err != nil {
12883 return _result, _err
12884 }
12885 }
12886 query := map[string]interface{}{}
12887 if !dara.IsNil(request.EvaluationCount) {
12888 query["EvaluationCount"] = request.EvaluationCount
12889 }
12890
12891 if !dara.IsNil(request.Interval) {
12892 query["Interval"] = request.Interval
12893 }
12894
12895 if !dara.IsNil(request.IspCityNode) {
12896 query["IspCityNode"] = request.IspCityNode
12897 }
12898
12899 if !dara.IsNil(request.Lang) {
12900 query["Lang"] = request.Lang
12901 }
12902
12903 if !dara.IsNil(request.MonitorConfigId) {
12904 query["MonitorConfigId"] = request.MonitorConfigId
12905 }
12906
12907 if !dara.IsNil(request.MonitorExtendInfo) {
12908 query["MonitorExtendInfo"] = request.MonitorExtendInfo
12909 }
12910
12911 if !dara.IsNil(request.ProtocolType) {
12912 query["ProtocolType"] = request.ProtocolType
12913 }
12914
12915 if !dara.IsNil(request.Timeout) {
12916 query["Timeout"] = request.Timeout
12917 }
12918
12919 req := &openapiutil.OpenApiRequest{
12920 Query: openapiutil.Query(query),
12921 }
12922 params := &openapiutil.Params{
12923 Action: dara.String("UpdateGtmMonitor"),
12924 Version: dara.String("2015-01-09"),
12925 Protocol: dara.String("HTTPS"),
12926 Pathname: dara.String("/"),
12927 Method: dara.String("POST"),
12928 AuthType: dara.String("AK"),
12929 Style: dara.String("RPC"),
12930 ReqBodyType: dara.String("formData"),
12931 BodyType: dara.String("json"),
12932 }
12933 _result = &UpdateGtmMonitorResponse{}
12934 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12935 if _err != nil {
12936 return _result, _err
12937 }
12938 _err = dara.Convert(_body, &_result)
12939 return _result, _err
12940 }
12941
12942 // Summary:
12943 //
12944 // Modifies a disaster recovery plan.
12945 //
12946 // @param request - UpdateGtmRecoveryPlanRequest
12947 //
12948 // @param runtime - runtime options for this request RuntimeOptions
12949 //
12950 // @return UpdateGtmRecoveryPlanResponse
12951 func UpdateGtmRecoveryPlanWithContext(ctx context.Context, client *Client, request *UpdateGtmRecoveryPlanRequest, runtime *dara.RuntimeOptions) (_result *UpdateGtmRecoveryPlanResponse, _err error) {
12952 if dara.BoolValue(client.EnableValidate) == true {
12953 _err = request.Validate()
12954 if _err != nil {
12955 return _result, _err
12956 }
12957 }
12958 query := map[string]interface{}{}
12959 if !dara.IsNil(request.FaultAddrPool) {
12960 query["FaultAddrPool"] = request.FaultAddrPool
12961 }
12962
12963 if !dara.IsNil(request.Lang) {
12964 query["Lang"] = request.Lang
12965 }
12966
12967 if !dara.IsNil(request.Name) {
12968 query["Name"] = request.Name
12969 }
12970
12971 if !dara.IsNil(request.RecoveryPlanId) {
12972 query["RecoveryPlanId"] = request.RecoveryPlanId
12973 }
12974
12975 if !dara.IsNil(request.Remark) {
12976 query["Remark"] = request.Remark
12977 }
12978
12979 req := &openapiutil.OpenApiRequest{
12980 Query: openapiutil.Query(query),
12981 }
12982 params := &openapiutil.Params{
12983 Action: dara.String("UpdateGtmRecoveryPlan"),
12984 Version: dara.String("2015-01-09"),
12985 Protocol: dara.String("HTTPS"),
12986 Pathname: dara.String("/"),
12987 Method: dara.String("POST"),
12988 AuthType: dara.String("AK"),
12989 Style: dara.String("RPC"),
12990 ReqBodyType: dara.String("formData"),
12991 BodyType: dara.String("json"),
12992 }
12993 _result = &UpdateGtmRecoveryPlanResponse{}
12994 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12995 if _err != nil {
12996 return _result, _err
12997 }
12998 _err = dara.Convert(_body, &_result)
12999 return _result, _err
13000 }
13001
13002 // Summary:
13003 //
13004 // 修改缓存刷新套餐包配置
13005 //
13006 // @param request - UpdateIspFlushCacheInstanceConfigRequest
13007 //
13008 // @param runtime - runtime options for this request RuntimeOptions
13009 //
13010 // @return UpdateIspFlushCacheInstanceConfigResponse
13011 func UpdateIspFlushCacheInstanceConfigWithContext(ctx context.Context, client *Client, request *UpdateIspFlushCacheInstanceConfigRequest, runtime *dara.RuntimeOptions) (_result *UpdateIspFlushCacheInstanceConfigResponse, _err error) {
13012 if dara.BoolValue(client.EnableValidate) == true {
13013 _err = request.Validate()
13014 if _err != nil {
13015 return _result, _err
13016 }
13017 }
13018 query := map[string]interface{}{}
13019 if !dara.IsNil(request.InstanceId) {
13020 query["InstanceId"] = request.InstanceId
13021 }
13022
13023 if !dara.IsNil(request.InstanceName) {
13024 query["InstanceName"] = request.InstanceName
13025 }
13026
13027 if !dara.IsNil(request.Lang) {
13028 query["Lang"] = request.Lang
13029 }
13030
13031 req := &openapiutil.OpenApiRequest{
13032 Query: openapiutil.Query(query),
13033 }
13034 params := &openapiutil.Params{
13035 Action: dara.String("UpdateIspFlushCacheInstanceConfig"),
13036 Version: dara.String("2015-01-09"),
13037 Protocol: dara.String("HTTPS"),
13038 Pathname: dara.String("/"),
13039 Method: dara.String("POST"),
13040 AuthType: dara.String("AK"),
13041 Style: dara.String("RPC"),
13042 ReqBodyType: dara.String("formData"),
13043 BodyType: dara.String("json"),
13044 }
13045 _result = &UpdateIspFlushCacheInstanceConfigResponse{}
13046 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13047 if _err != nil {
13048 return _result, _err
13049 }
13050 _err = dara.Convert(_body, &_result)
13051 return _result, _err
13052 }
13053
13054 // Summary:
13055 //
13056 // 修改递归解析内置权威解析记录
13057 //
13058 // @param request - UpdateRecursionRecordRequest
13059 //
13060 // @param runtime - runtime options for this request RuntimeOptions
13061 //
13062 // @return UpdateRecursionRecordResponse
13063 func UpdateRecursionRecordWithContext(ctx context.Context, client *Client, request *UpdateRecursionRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordResponse, _err error) {
13064 if dara.BoolValue(client.EnableValidate) == true {
13065 _err = request.Validate()
13066 if _err != nil {
13067 return _result, _err
13068 }
13069 }
13070 query := map[string]interface{}{}
13071 if !dara.IsNil(request.ClientToken) {
13072 query["ClientToken"] = request.ClientToken
13073 }
13074
13075 if !dara.IsNil(request.Priority) {
13076 query["Priority"] = request.Priority
13077 }
13078
13079 if !dara.IsNil(request.RecordId) {
13080 query["RecordId"] = request.RecordId
13081 }
13082
13083 if !dara.IsNil(request.RequestSource) {
13084 query["RequestSource"] = request.RequestSource
13085 }
13086
13087 if !dara.IsNil(request.Rr) {
13088 query["Rr"] = request.Rr
13089 }
13090
13091 if !dara.IsNil(request.Ttl) {
13092 query["Ttl"] = request.Ttl
13093 }
13094
13095 if !dara.IsNil(request.Type) {
13096 query["Type"] = request.Type
13097 }
13098
13099 if !dara.IsNil(request.Value) {
13100 query["Value"] = request.Value
13101 }
13102
13103 if !dara.IsNil(request.Weight) {
13104 query["Weight"] = request.Weight
13105 }
13106
13107 req := &openapiutil.OpenApiRequest{
13108 Query: openapiutil.Query(query),
13109 }
13110 params := &openapiutil.Params{
13111 Action: dara.String("UpdateRecursionRecord"),
13112 Version: dara.String("2015-01-09"),
13113 Protocol: dara.String("HTTPS"),
13114 Pathname: dara.String("/"),
13115 Method: dara.String("POST"),
13116 AuthType: dara.String("AK"),
13117 Style: dara.String("RPC"),
13118 ReqBodyType: dara.String("formData"),
13119 BodyType: dara.String("json"),
13120 }
13121 _result = &UpdateRecursionRecordResponse{}
13122 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13123 if _err != nil {
13124 return _result, _err
13125 }
13126 _err = dara.Convert(_body, &_result)
13127 return _result, _err
13128 }
13129
13130 // Summary:
13131 //
13132 // 修改内置权威解析记录启用状态
13133 //
13134 // @param request - UpdateRecursionRecordEnableStatusRequest
13135 //
13136 // @param runtime - runtime options for this request RuntimeOptions
13137 //
13138 // @return UpdateRecursionRecordEnableStatusResponse
13139 func UpdateRecursionRecordEnableStatusWithContext(ctx context.Context, client *Client, request *UpdateRecursionRecordEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordEnableStatusResponse, _err error) {
13140 if dara.BoolValue(client.EnableValidate) == true {
13141 _err = request.Validate()
13142 if _err != nil {
13143 return _result, _err
13144 }
13145 }
13146 query := map[string]interface{}{}
13147 if !dara.IsNil(request.ClientToken) {
13148 query["ClientToken"] = request.ClientToken
13149 }
13150
13151 if !dara.IsNil(request.EnableStatus) {
13152 query["EnableStatus"] = request.EnableStatus
13153 }
13154
13155 if !dara.IsNil(request.RecordId) {
13156 query["RecordId"] = request.RecordId
13157 }
13158
13159 req := &openapiutil.OpenApiRequest{
13160 Query: openapiutil.Query(query),
13161 }
13162 params := &openapiutil.Params{
13163 Action: dara.String("UpdateRecursionRecordEnableStatus"),
13164 Version: dara.String("2015-01-09"),
13165 Protocol: dara.String("HTTPS"),
13166 Pathname: dara.String("/"),
13167 Method: dara.String("POST"),
13168 AuthType: dara.String("AK"),
13169 Style: dara.String("RPC"),
13170 ReqBodyType: dara.String("formData"),
13171 BodyType: dara.String("json"),
13172 }
13173 _result = &UpdateRecursionRecordEnableStatusResponse{}
13174 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13175 if _err != nil {
13176 return _result, _err
13177 }
13178 _err = dara.Convert(_body, &_result)
13179 return _result, _err
13180 }
13181
13182 // Summary:
13183 //
13184 // 修改递归解析内置权威解析记录备注
13185 //
13186 // @param request - UpdateRecursionRecordRemarkRequest
13187 //
13188 // @param runtime - runtime options for this request RuntimeOptions
13189 //
13190 // @return UpdateRecursionRecordRemarkResponse
13191 func UpdateRecursionRecordRemarkWithContext(ctx context.Context, client *Client, request *UpdateRecursionRecordRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordRemarkResponse, _err error) {
13192 if dara.BoolValue(client.EnableValidate) == true {
13193 _err = request.Validate()
13194 if _err != nil {
13195 return _result, _err
13196 }
13197 }
13198 query := map[string]interface{}{}
13199 if !dara.IsNil(request.ClientToken) {
13200 query["ClientToken"] = request.ClientToken
13201 }
13202
13203 if !dara.IsNil(request.RecordId) {
13204 query["RecordId"] = request.RecordId
13205 }
13206
13207 if !dara.IsNil(request.Remark) {
13208 query["Remark"] = request.Remark
13209 }
13210
13211 req := &openapiutil.OpenApiRequest{
13212 Query: openapiutil.Query(query),
13213 }
13214 params := &openapiutil.Params{
13215 Action: dara.String("UpdateRecursionRecordRemark"),
13216 Version: dara.String("2015-01-09"),
13217 Protocol: dara.String("HTTPS"),
13218 Pathname: dara.String("/"),
13219 Method: dara.String("POST"),
13220 AuthType: dara.String("AK"),
13221 Style: dara.String("RPC"),
13222 ReqBodyType: dara.String("formData"),
13223 BodyType: dara.String("json"),
13224 }
13225 _result = &UpdateRecursionRecordRemarkResponse{}
13226 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13227 if _err != nil {
13228 return _result, _err
13229 }
13230 _err = dara.Convert(_body, &_result)
13231 return _result, _err
13232 }
13233
13234 // Summary:
13235 //
13236 // 修改递归解析内置权威解析记录权重
13237 //
13238 // @param request - UpdateRecursionRecordWeightRequest
13239 //
13240 // @param runtime - runtime options for this request RuntimeOptions
13241 //
13242 // @return UpdateRecursionRecordWeightResponse
13243 func UpdateRecursionRecordWeightWithContext(ctx context.Context, client *Client, request *UpdateRecursionRecordWeightRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordWeightResponse, _err error) {
13244 if dara.BoolValue(client.EnableValidate) == true {
13245 _err = request.Validate()
13246 if _err != nil {
13247 return _result, _err
13248 }
13249 }
13250 query := map[string]interface{}{}
13251 if !dara.IsNil(request.ClientToken) {
13252 query["ClientToken"] = request.ClientToken
13253 }
13254
13255 if !dara.IsNil(request.RecordId) {
13256 query["RecordId"] = request.RecordId
13257 }
13258
13259 if !dara.IsNil(request.Weight) {
13260 query["Weight"] = request.Weight
13261 }
13262
13263 req := &openapiutil.OpenApiRequest{
13264 Query: openapiutil.Query(query),
13265 }
13266 params := &openapiutil.Params{
13267 Action: dara.String("UpdateRecursionRecordWeight"),
13268 Version: dara.String("2015-01-09"),
13269 Protocol: dara.String("HTTPS"),
13270 Pathname: dara.String("/"),
13271 Method: dara.String("POST"),
13272 AuthType: dara.String("AK"),
13273 Style: dara.String("RPC"),
13274 ReqBodyType: dara.String("formData"),
13275 BodyType: dara.String("json"),
13276 }
13277 _result = &UpdateRecursionRecordWeightResponse{}
13278 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13279 if _err != nil {
13280 return _result, _err
13281 }
13282 _err = dara.Convert(_body, &_result)
13283 return _result, _err
13284 }
13285
13286 // Summary:
13287 //
13288 // 修改递归解析内置权威解析记录权重算法启用状态
13289 //
13290 // @param request - UpdateRecursionRecordWeightEnableStatusRequest
13291 //
13292 // @param runtime - runtime options for this request RuntimeOptions
13293 //
13294 // @return UpdateRecursionRecordWeightEnableStatusResponse
13295 func UpdateRecursionRecordWeightEnableStatusWithContext(ctx context.Context, client *Client, request *UpdateRecursionRecordWeightEnableStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionRecordWeightEnableStatusResponse, _err error) {
13296 if dara.BoolValue(client.EnableValidate) == true {
13297 _err = request.Validate()
13298 if _err != nil {
13299 return _result, _err
13300 }
13301 }
13302 query := map[string]interface{}{}
13303 if !dara.IsNil(request.ClientToken) {
13304 query["ClientToken"] = request.ClientToken
13305 }
13306
13307 if !dara.IsNil(request.EnableStatus) {
13308 query["EnableStatus"] = request.EnableStatus
13309 }
13310
13311 if !dara.IsNil(request.RequestSource) {
13312 query["RequestSource"] = request.RequestSource
13313 }
13314
13315 if !dara.IsNil(request.Rr) {
13316 query["Rr"] = request.Rr
13317 }
13318
13319 if !dara.IsNil(request.Type) {
13320 query["Type"] = request.Type
13321 }
13322
13323 if !dara.IsNil(request.ZoneId) {
13324 query["ZoneId"] = request.ZoneId
13325 }
13326
13327 req := &openapiutil.OpenApiRequest{
13328 Query: openapiutil.Query(query),
13329 }
13330 params := &openapiutil.Params{
13331 Action: dara.String("UpdateRecursionRecordWeightEnableStatus"),
13332 Version: dara.String("2015-01-09"),
13333 Protocol: dara.String("HTTPS"),
13334 Pathname: dara.String("/"),
13335 Method: dara.String("POST"),
13336 AuthType: dara.String("AK"),
13337 Style: dara.String("RPC"),
13338 ReqBodyType: dara.String("formData"),
13339 BodyType: dara.String("json"),
13340 }
13341 _result = &UpdateRecursionRecordWeightEnableStatusResponse{}
13342 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13343 if _err != nil {
13344 return _result, _err
13345 }
13346 _err = dara.Convert(_body, &_result)
13347 return _result, _err
13348 }
13349
13350 // Summary:
13351 //
13352 // 修改递归解析内置权威域名zone生效范围
13353 //
13354 // @param tmpReq - UpdateRecursionZoneEffectiveScopeRequest
13355 //
13356 // @param runtime - runtime options for this request RuntimeOptions
13357 //
13358 // @return UpdateRecursionZoneEffectiveScopeResponse
13359 func UpdateRecursionZoneEffectiveScopeWithContext(ctx context.Context, client *Client, tmpReq *UpdateRecursionZoneEffectiveScopeRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneEffectiveScopeResponse, _err error) {
13360 if dara.BoolValue(client.EnableValidate) == true {
13361 _err = tmpReq.Validate()
13362 if _err != nil {
13363 return _result, _err
13364 }
13365 }
13366 request := &UpdateRecursionZoneEffectiveScopeShrinkRequest{}
13367 openapiutil.Convert(tmpReq, request)
13368 if !dara.IsNil(tmpReq.EffectiveScopes) {
13369 request.EffectiveScopesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.EffectiveScopes, dara.String("EffectiveScopes"), dara.String("json"))
13370 }
13371
13372 query := map[string]interface{}{}
13373 if !dara.IsNil(request.ClientToken) {
13374 query["ClientToken"] = request.ClientToken
13375 }
13376
13377 if !dara.IsNil(request.EffectiveScopesShrink) {
13378 query["EffectiveScopes"] = request.EffectiveScopesShrink
13379 }
13380
13381 if !dara.IsNil(request.ZoneId) {
13382 query["ZoneId"] = request.ZoneId
13383 }
13384
13385 req := &openapiutil.OpenApiRequest{
13386 Query: openapiutil.Query(query),
13387 }
13388 params := &openapiutil.Params{
13389 Action: dara.String("UpdateRecursionZoneEffectiveScope"),
13390 Version: dara.String("2015-01-09"),
13391 Protocol: dara.String("HTTPS"),
13392 Pathname: dara.String("/"),
13393 Method: dara.String("POST"),
13394 AuthType: dara.String("AK"),
13395 Style: dara.String("RPC"),
13396 ReqBodyType: dara.String("formData"),
13397 BodyType: dara.String("json"),
13398 }
13399 _result = &UpdateRecursionZoneEffectiveScopeResponse{}
13400 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13401 if _err != nil {
13402 return _result, _err
13403 }
13404 _err = dara.Convert(_body, &_result)
13405 return _result, _err
13406 }
13407
13408 // Summary:
13409 //
13410 // 修改递归解析内置权威域名zone递归代理模式
13411 //
13412 // @param request - UpdateRecursionZoneProxyPatternRequest
13413 //
13414 // @param runtime - runtime options for this request RuntimeOptions
13415 //
13416 // @return UpdateRecursionZoneProxyPatternResponse
13417 func UpdateRecursionZoneProxyPatternWithContext(ctx context.Context, client *Client, request *UpdateRecursionZoneProxyPatternRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneProxyPatternResponse, _err error) {
13418 if dara.BoolValue(client.EnableValidate) == true {
13419 _err = request.Validate()
13420 if _err != nil {
13421 return _result, _err
13422 }
13423 }
13424 query := map[string]interface{}{}
13425 if !dara.IsNil(request.ClientToken) {
13426 query["ClientToken"] = request.ClientToken
13427 }
13428
13429 if !dara.IsNil(request.ProxyPattern) {
13430 query["ProxyPattern"] = request.ProxyPattern
13431 }
13432
13433 if !dara.IsNil(request.ZoneId) {
13434 query["ZoneId"] = request.ZoneId
13435 }
13436
13437 req := &openapiutil.OpenApiRequest{
13438 Query: openapiutil.Query(query),
13439 }
13440 params := &openapiutil.Params{
13441 Action: dara.String("UpdateRecursionZoneProxyPattern"),
13442 Version: dara.String("2015-01-09"),
13443 Protocol: dara.String("HTTPS"),
13444 Pathname: dara.String("/"),
13445 Method: dara.String("POST"),
13446 AuthType: dara.String("AK"),
13447 Style: dara.String("RPC"),
13448 ReqBodyType: dara.String("formData"),
13449 BodyType: dara.String("json"),
13450 }
13451 _result = &UpdateRecursionZoneProxyPatternResponse{}
13452 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13453 if _err != nil {
13454 return _result, _err
13455 }
13456 _err = dara.Convert(_body, &_result)
13457 return _result, _err
13458 }
13459
13460 // Summary:
13461 //
13462 // 修改递归解析内置权威域名zone备注
13463 //
13464 // @param request - UpdateRecursionZoneRemarkRequest
13465 //
13466 // @param runtime - runtime options for this request RuntimeOptions
13467 //
13468 // @return UpdateRecursionZoneRemarkResponse
13469 func UpdateRecursionZoneRemarkWithContext(ctx context.Context, client *Client, request *UpdateRecursionZoneRemarkRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecursionZoneRemarkResponse, _err error) {
13470 if dara.BoolValue(client.EnableValidate) == true {
13471 _err = request.Validate()
13472 if _err != nil {
13473 return _result, _err
13474 }
13475 }
13476 query := map[string]interface{}{}
13477 if !dara.IsNil(request.ClientToken) {
13478 query["ClientToken"] = request.ClientToken
13479 }
13480
13481 if !dara.IsNil(request.Remark) {
13482 query["Remark"] = request.Remark
13483 }
13484
13485 if !dara.IsNil(request.ZoneId) {
13486 query["ZoneId"] = request.ZoneId
13487 }
13488
13489 req := &openapiutil.OpenApiRequest{
13490 Query: openapiutil.Query(query),
13491 }
13492 params := &openapiutil.Params{
13493 Action: dara.String("UpdateRecursionZoneRemark"),
13494 Version: dara.String("2015-01-09"),
13495 Protocol: dara.String("HTTPS"),
13496 Pathname: dara.String("/"),
13497 Method: dara.String("POST"),
13498 AuthType: dara.String("AK"),
13499 Style: dara.String("RPC"),
13500 ReqBodyType: dara.String("formData"),
13501 BodyType: dara.String("json"),
13502 }
13503 _result = &UpdateRecursionZoneRemarkResponse{}
13504 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13505 if _err != nil {
13506 return _result, _err
13507 }
13508 _err = dara.Convert(_body, &_result)
13509 return _result, _err
13510 }
13511
13512 // Summary:
13513 //
13514 // 用于更新域名的状态属性
13515 //
13516 // Description:
13517 //
13518 // ## 请求说明
13519 //
13520 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
13521 //
13522 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
13523 //
13524 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
13525 //
13526 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
13527 //
13528 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
13529 //
13530 // @param request - UpdateRspDomainServerHoldStatusOteRequest
13531 //
13532 // @param runtime - runtime options for this request RuntimeOptions
13533 //
13534 // @return UpdateRspDomainServerHoldStatusOteResponse
13535 func UpdateRspDomainServerHoldStatusOteWithContext(ctx context.Context, client *Client, request *UpdateRspDomainServerHoldStatusOteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRspDomainServerHoldStatusOteResponse, _err error) {
13536 if dara.BoolValue(client.EnableValidate) == true {
13537 _err = request.Validate()
13538 if _err != nil {
13539 return _result, _err
13540 }
13541 }
13542 query := map[string]interface{}{}
13543 if !dara.IsNil(request.ClientToken) {
13544 query["ClientToken"] = request.ClientToken
13545 }
13546
13547 if !dara.IsNil(request.DomainName) {
13548 query["DomainName"] = request.DomainName
13549 }
13550
13551 if !dara.IsNil(request.OperatorId) {
13552 query["OperatorId"] = request.OperatorId
13553 }
13554
13555 if !dara.IsNil(request.OperatorType) {
13556 query["OperatorType"] = request.OperatorType
13557 }
13558
13559 if !dara.IsNil(request.ServerHoldStatus) {
13560 query["ServerHoldStatus"] = request.ServerHoldStatus
13561 }
13562
13563 if !dara.IsNil(request.StatusMsg) {
13564 query["StatusMsg"] = request.StatusMsg
13565 }
13566
13567 req := &openapiutil.OpenApiRequest{
13568 Query: openapiutil.Query(query),
13569 }
13570 params := &openapiutil.Params{
13571 Action: dara.String("UpdateRspDomainServerHoldStatusOte"),
13572 Version: dara.String("2015-01-09"),
13573 Protocol: dara.String("HTTPS"),
13574 Pathname: dara.String("/"),
13575 Method: dara.String("POST"),
13576 AuthType: dara.String("AK"),
13577 Style: dara.String("RPC"),
13578 ReqBodyType: dara.String("formData"),
13579 BodyType: dara.String("json"),
13580 }
13581 _result = &UpdateRspDomainServerHoldStatusOteResponse{}
13582 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13583 if _err != nil {
13584 return _result, _err
13585 }
13586 _err = dara.Convert(_body, &_result)
13587 return _result, _err
13588 }
13589
13590 // Summary:
13591 //
13592 // 用于更新域名的状态属性
13593 //
13594 // Description:
13595 //
13596 // ## 请求说明
13597 //
13598 // - 本接口专为注册局用户设计，允许他们更新指定顶级域名（TLD）的各种属性。
13599 //
13600 // - 必须提供`RegistryId`和`Tld`参数以标识要修改的具体TLD。
13601 //
13602 // - 可选参数包括但不限于宽限期设置、DNS解析缓存时间、价格设定等，这些都可根据需要进行调整。
13603 //
13604 // - 环境(`Env`)参数指定了API调用的目标环境，默认值为“DAILY”表示日常测试环境；正式上线前，请确保已正确设置此参数。
13605 //
13606 // - 某些时间戳字段如`SunriseStartTimeStamp`要求输入Unix时间戳格式的数据。
13607 //
13608 // @param request - UpdateRspDomainStatusOteRequest
13609 //
13610 // @param runtime - runtime options for this request RuntimeOptions
13611 //
13612 // @return UpdateRspDomainStatusOteResponse
13613 func UpdateRspDomainStatusOteWithContext(ctx context.Context, client *Client, request *UpdateRspDomainStatusOteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRspDomainStatusOteResponse, _err error) {
13614 if dara.BoolValue(client.EnableValidate) == true {
13615 _err = request.Validate()
13616 if _err != nil {
13617 return _result, _err
13618 }
13619 }
13620 query := map[string]interface{}{}
13621 if !dara.IsNil(request.AddStatusList) {
13622 query["AddStatusList"] = request.AddStatusList
13623 }
13624
13625 if !dara.IsNil(request.ClientToken) {
13626 query["ClientToken"] = request.ClientToken
13627 }
13628
13629 if !dara.IsNil(request.DeleteStatusList) {
13630 query["DeleteStatusList"] = request.DeleteStatusList
13631 }
13632
13633 if !dara.IsNil(request.DomainName) {
13634 query["DomainName"] = request.DomainName
13635 }
13636
13637 if !dara.IsNil(request.OperatorId) {
13638 query["OperatorId"] = request.OperatorId
13639 }
13640
13641 if !dara.IsNil(request.OperatorType) {
13642 query["OperatorType"] = request.OperatorType
13643 }
13644
13645 req := &openapiutil.OpenApiRequest{
13646 Query: openapiutil.Query(query),
13647 }
13648 params := &openapiutil.Params{
13649 Action: dara.String("UpdateRspDomainStatusOte"),
13650 Version: dara.String("2015-01-09"),
13651 Protocol: dara.String("HTTPS"),
13652 Pathname: dara.String("/"),
13653 Method: dara.String("POST"),
13654 AuthType: dara.String("AK"),
13655 Style: dara.String("RPC"),
13656 ReqBodyType: dara.String("formData"),
13657 BodyType: dara.String("json"),
13658 }
13659 _result = &UpdateRspDomainStatusOteResponse{}
13660 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13661 if _err != nil {
13662 return _result, _err
13663 }
13664 _err = dara.Convert(_body, &_result)
13665 return _result, _err
13666 }
13667
13668 // Summary:
13669 //
13670 // 检查实例主机名是否可添加
13671 //
13672 // @param request - ValidateDnsGtmCnameRrCanUseRequest
13673 //
13674 // @param runtime - runtime options for this request RuntimeOptions
13675 //
13676 // @return ValidateDnsGtmCnameRrCanUseResponse
13677 func ValidateDnsGtmCnameRrCanUseWithContext(ctx context.Context, client *Client, request *ValidateDnsGtmCnameRrCanUseRequest, runtime *dara.RuntimeOptions) (_result *ValidateDnsGtmCnameRrCanUseResponse, _err error) {
13678 if dara.BoolValue(client.EnableValidate) == true {
13679 _err = request.Validate()
13680 if _err != nil {
13681 return _result, _err
13682 }
13683 }
13684 query := map[string]interface{}{}
13685 if !dara.IsNil(request.CnameMode) {
13686 query["CnameMode"] = request.CnameMode
13687 }
13688
13689 if !dara.IsNil(request.CnameRr) {
13690 query["CnameRr"] = request.CnameRr
13691 }
13692
13693 if !dara.IsNil(request.CnameType) {
13694 query["CnameType"] = request.CnameType
13695 }
13696
13697 if !dara.IsNil(request.CnameZone) {
13698 query["CnameZone"] = request.CnameZone
13699 }
13700
13701 if !dara.IsNil(request.InstanceId) {
13702 query["InstanceId"] = request.InstanceId
13703 }
13704
13705 if !dara.IsNil(request.Lang) {
13706 query["Lang"] = request.Lang
13707 }
13708
13709 req := &openapiutil.OpenApiRequest{
13710 Query: openapiutil.Query(query),
13711 }
13712 params := &openapiutil.Params{
13713 Action: dara.String("ValidateDnsGtmCnameRrCanUse"),
13714 Version: dara.String("2015-01-09"),
13715 Protocol: dara.String("HTTPS"),
13716 Pathname: dara.String("/"),
13717 Method: dara.String("POST"),
13718 AuthType: dara.String("AK"),
13719 Style: dara.String("RPC"),
13720 ReqBodyType: dara.String("formData"),
13721 BodyType: dara.String("json"),
13722 }
13723 _result = &ValidateDnsGtmCnameRrCanUseResponse{}
13724 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13725 if _err != nil {
13726 return _result, _err
13727 }
13728 _err = dara.Convert(_body, &_result)
13729 return _result, _err
13730 }
13731
13732 // Summary:
13733 //
13734 // 验证公共DNS Udp Ip地址段
13735 //
13736 // @param request - ValidatePdnsUdpIpSegmentRequest
13737 //
13738 // @param runtime - runtime options for this request RuntimeOptions
13739 //
13740 // @return ValidatePdnsUdpIpSegmentResponse
13741 func ValidatePdnsUdpIpSegmentWithContext(ctx context.Context, client *Client, request *ValidatePdnsUdpIpSegmentRequest, runtime *dara.RuntimeOptions) (_result *ValidatePdnsUdpIpSegmentResponse, _err error) {
13742 if dara.BoolValue(client.EnableValidate) == true {
13743 _err = request.Validate()
13744 if _err != nil {
13745 return _result, _err
13746 }
13747 }
13748 query := map[string]interface{}{}
13749 if !dara.IsNil(request.Ip) {
13750 query["Ip"] = request.Ip
13751 }
13752
13753 if !dara.IsNil(request.IpToken) {
13754 query["IpToken"] = request.IpToken
13755 }
13756
13757 if !dara.IsNil(request.Lang) {
13758 query["Lang"] = request.Lang
13759 }
13760
13761 req := &openapiutil.OpenApiRequest{
13762 Query: openapiutil.Query(query),
13763 }
13764 params := &openapiutil.Params{
13765 Action: dara.String("ValidatePdnsUdpIpSegment"),
13766 Version: dara.String("2015-01-09"),
13767 Protocol: dara.String("HTTPS"),
13768 Pathname: dara.String("/"),
13769 Method: dara.String("POST"),
13770 AuthType: dara.String("AK"),
13771 Style: dara.String("RPC"),
13772 ReqBodyType: dara.String("formData"),
13773 BodyType: dara.String("json"),
13774 }
13775 _result = &ValidatePdnsUdpIpSegmentResponse{}
13776 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13777 if _err != nil {
13778 return _result, _err
13779 }
13780 _err = dara.Convert(_body, &_result)
13781 return _result, _err
13782 }
13783